
/* 
 * Argyll Color Correction System
 * Test target chart Generator.
 *
 * Author: Graeme W. Gill
 * Date:   28/9/96
 *
 * Copyright 1996 - 2004, Graeme W. Gill
 * All rights reserved.
 *
 * This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
 * see the License.txt file for licencing details.
 */

/* This program generates a CGATS.5 compatibe file, that */
/* containing device color test patch values. */

/* TTBD:

	Include command line aruments in resulting .ti1 file.

	Should add an option to generate other PCS based pattern
	test points based on the previous profile. (i.e. near neutral
	clusters ?)
	How about an option to read in an CGATS file containing
	PCS or device values ? How is the black level chosen for PCS though ?

	Would be nice to be able to take a previous .ti3 and
	then suppliment the measured patches. Would have to add another
	set of measurement columns to .ti1 & .ti2 to carry the
	already measured values through, or do clumbsy post merge ? 
	(Latter is easiest).

	Would be nice to be able to generate secondary
	color ramps (ie. CMY for RGB space, RGB for CMYK space.)

	Using adaptive patch creation for grey colorspace is broken.
	This should be fixed.

	Would be nice to have a generator of "well behaved" device
	gamut surface points. Would need a way of creating
	a gamut surface from the .ti3 file though.

	If linearized (aka underlying) ink limit information (i.e. .cal) is available,
	perhaps we should filter all the patch values before
 	we write the .ti1 out to make sure they are under the limit ?
 */

/* NOTE:

	xpow is applied over the top of the normal or supplied
	device model, so it effectively becomes a modification
	of the device model.

	The general filter is applied prior to the xpow being applied.
	Many of the test patch types do take it into account
	when computing the ink limit.
	The ones that don't are the more complicated full spread patches.

 */

/* Description:

   Nearly all current Color correction systems generate test charts (or
   device characterisation target charts) by laying out a regular rectangular
   grid of test points in device space (Targen will do this if you feed it a non-zero
   m option). On some consideration, this approach is far from optimal. Not only
   is a regular grid inefficent in packing the multidimentional device space,
   but if the points are spaced evenly in device space, they will be poorly
   spaced in human perceptual space, and errors in perceptual space are
   the ultimate arbiter of the end profiles accuracy. Some commercial
   color systems tackle the latter problem by "pre-linearising" the device,
   which amounts to distorting the regular device space grid points with
   a perceptual inverse per device chanel lookup curve.

   The approach I have taken with Argyll, is a little different. By
   using an iterative sphere packing algorithm, I constrain the given
   number of test points to the devices physical gamut (including an
   ink limit for a printer device), and then try and pack the points
   evenly in human perceptual space, or even space them to minimise
   curvature approximation errors. Because the packing is a stocastic
   process, the resulting points are distributed without evident
   patterns.

   For higher dimensional spaces, where the aim is to create a
   more aproximate device profile, I've used an "incremental far
   point" point generator, that for each added point, locates
   the device values that result in a percetual value farthest
   from any existing points in the test set.

   Other algorithms for point generation are available too.

   Another issue with laying test points out in regular grids, is
   that this means that the device response is poorly sampled
   (since the grids are usually coarse), and this can make it
   impossible to create detailed device linearisation "shaper"
   curves from the resulting data !
   Ideally, in any colorspace (input or output), when viewed from
   any possible angle, none of the test data points should appear
   to line up. The Argyll target generator seems to acheive this goal.

   A final problem withe regular grids is that they can lead to
   Runge's phenomenon, depending on the nature of the interpolation
   algorithm used.

 */

#undef DEBUG

#define VRML_DIAG		/* Enable option to dump a VRML/X3D of the resulting full spread points */
#undef ADDRECCLIPPOINTS	/* Add ink limited clipping points to regular grid */
#define EMPH_NEUTRAL	/* Emphasise neutral axis, like CIE94 does */
#define NEMPH_DEFAULT 0.5	/* Default neutral axis emphasis == 2 x CIE94 */
#define XPOW_DEFAULT 1.0	/* Default extra device power value = none */
#define DEFANGLE 0.3333	/* For simdlat and simplat */
#define SIMDLAT_TYPE SIMDLAT_BCC	/* Simdlat geometry type */
#define MATCH_TOLL 1e-4	/* Tollerance of device value to consider a patch a duplicate */

/* Display rise and fall time delay model. This is CRT like */
#define DISPLAY_RISE_TIME DISPTECH_WORST_RISE		/* Assumed rise time to 90% of target level */ 
#define DISPLAY_FALL_TIME DISPTECH_WORST_FALL		/* Assumed fall time to 90% of target level */
#define DISPLAY_SETTLE_AIM 0.1		/* Aim for 0.2 Delta E */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <stdarg.h>
#include "copyright.h"
#include "aconfig.h"
#include "numlib.h"
#include "vrml.h"
#include "rspl.h"
#include "cgats.h"
#include "icc.h"
#include "conv.h"
#include "xicc.h"
#include "disptechs.h"
#include "targen.h"
//#include "ppoint.h"
#include "ofps.h"
#include "ifarp.h"
#include "simplat.h"
#include "simdlat.h"
#include "prand.h"
#include "ui.h"

#define min2(a,b) ((a) < (b) ? (a) : (b))
#define min3(a,b,c)  (min2((a), min2((b),(c))))
#define max2(a,b) ((a) > (b) ? (a) : (b))
#define max3(a,b,c)  (max2((a), max2((b),(c))))

/* 32 bit pseudo random sequencer */
#define PSRAND32(S) (((S) & 0x80000000) ? (((S) << 1) ^ 0xa398655d) : ((S) << 1))

/* ---------------------------- */

static double spow(double v, double p) {
	if (v < 0.0)
		return -pow(-v, p);
	else
		return pow(v, p);
}   

/* ---------------------------- */
/* The perception function data */
/* (Used for test point distribution) */
struct _pcpt {
/* public: */
	void (*del)(struct _pcpt *s);	/* We're done with it */

	int (*is_specific)(struct _pcpt *s);	/* Is a specific model, not default */

	/* Conversions */
	void (*dev_to_perc)(struct _pcpt *s, double *out, double *in);	/* N-chan Perceptual */
	void (*dev_to_XYZ)(struct _pcpt *s, double *out, double *in);	/* Absolute XYZ */
	void (*dev_to_rLab)(struct _pcpt *s, double *out, double *in);	/* Relative Lab */
	void (*den_to_dev)(struct _pcpt *s, double *out, double *in);	/* Density to device */
	void (*rLab_to_dev)(struct _pcpt *s, double *out, double *in);	/* Lab to device */

	/* !!! Should add perc_to_dev using code from prand that uses dnsq !!! */

	/* Scale/clip device values to meet any ink limit */
	/* Return nz if changed value. */
	int (*limit_ink)(struct _pcpt *s, double *inout);

/* private: */
	inkmask xmask;		/* external xcolorants inkmask */
	inkmask nmask;		/* internal xcolorants inkmask */
	int di;				/* Number of Device dimensions */

	/* Tuning parameters */
	double nemph;		/* neutral emphasis, 0.0 - 1.0. Default 0.35 for == CIE94 */
	double idemph;		/* inv. of dark emphasis, 1.0 - 0.25. Default 1.0 == none */
						/* 1.0 - 4.0 for light emphasis */
	double ixpow;		/* inv. extra power Default 1.0 == none */

	/* ICC profile based */
	icmFile *fp;
	icc   *icco;
	icmLuSpace *luo;	/* Device -> rLab conversion */
	icmLuSpace *luo2;	/* Device -> XYZ conversion */

	/* MPP profile based */
	mpp *mlu;			/* Device -> XYZ */

	/* Xcolorants model based */
	icxColorantLu *clu;	/* Device -> CIE */

	rspl *nlin[MXTD - 3];	/* Perceptual linearisation for channels beyond the third, i.e. K */
	int e;					/* Chanel being set */

	/* Reverse lookup support */
	double uilimit;			/* linearized (underlying) ink limit (scale 1.0) */
	double den[3];			/* Target density or Lab */
	double uniform;			/* NZ if target is uniform */	
	int kchan;				/* Set to the K chanel (-1 if none) */

	/* Full ink limiting information (not currently used by sample point generator code) */
	double ilimit;			/* final raw ink limit (scale 1.0) */
	xcal *cal;				/* if !NULL, linearized to final raw conversion */

}; typedef struct _pcpt pcpt;

/* Absolute XYZ conversion function */
/* Internal device values 0.0 - 1.0 are converted into XYZ values */
/* (Used for downstream checking) */
static void
pcpt_to_XYZ(pcpt *s, double *out, double *in) {
	int e; 
	double inv[MXTD];

	if (s->xmask == s->nmask) {
		for (e = 0; e < s->di; e++)
			inv[e] = icx_powlike(in[e], s->ixpow);
	} else {
		for (e = 0; e < s->di; e++)
			inv[e] = 1.0 - icx_powlike(in[e], s->ixpow);
	}
	if (s->luo2 != NULL)
		s->luo2->lookup_fwd(s->luo2, out, inv);
	else if (s->mlu != NULL)
		s->mlu->lookup(s->mlu, out, inv);
	else  if (s->clu != NULL)
		s->clu->dev_to_XYZ(s->clu, out, inv);
	else {	/* Linear conversion */
		out[0] = 100.0 * inv[0];
		out[1] = 100.0 * inv[1] - 50.0;
		out[2] = 100.0 * inv[2] - 50.0;
		icmLab2XYZ(&icmD50, out, out);
	}
}

/* Relative Lab conversion function */
/* Internal device values 0.0 - 1.0 are converted into Lab values */
/* (Used for VRML/X3D visualisation checking) */
static void
pcpt_to_rLab(pcpt *s, double *out, double *in) {
	int e; 
	double inv[MXTD];

	if (s->xmask == s->nmask) {
		for (e = 0; e < s->di; e++)
			inv[e] = icx_powlike(in[e], s->ixpow);
	} else {
		for (e = 0; e < s->di; e++)
			inv[e] = 1.0 - icx_powlike(in[e], s->ixpow);
	}
	if (s->luo != NULL)
		s->luo->lookup_fwd(s->luo, out, inv);
	else if (s->mlu != NULL) {
		s->mlu->lookup(s->mlu, out, inv);
		icmXYZ2Lab(&icmD50, out, out);
	} else if (s->clu != NULL) 
		s->clu->dev_to_rLab(s->clu, out, inv);
	else {	/* Linear conversion */
		out[0] = 100.0 * inv[0];
		out[1] = 100.0 * inv[1] - 50.0;
		out[2] = 100.0 * inv[2] - 50.0;
	}
}

/* Perceptual conversion function */
/* Internal device values 0.0 - 1.0 are converted into perceptually uniform 0.0 - 100.0 */
/* This is used by optimal spread functions */
static void
pcpt_to_nLab(pcpt *s, double *out, double *in) {
	int e;
	double inv[MXTD];		/* Input value after applying extra power */

	if (s->xmask == s->nmask) {
		for (e = 0; e < s->di; e++)
			inv[e] = icx_powlike(in[e], s->ixpow);
	} else {
		for (e = 0; e < s->di; e++)
			inv[e] = 1.0 - icx_powlike(in[e], s->ixpow);
	}

	/* If we have some sort of perceptual conversion */
	if (s->luo != NULL || s->mlu != NULL || s->clu != NULL) {
		double lab[3];

		if (s->luo != NULL)
			s->luo->lookup_fwd(s->luo, lab, inv);
		else if (s->mlu != NULL) {
			s->mlu->lookup(s->mlu, lab, inv);
			icmXYZ2Lab(&icmD50, lab, lab);
		} else { 
			s->clu->dev_to_rLab(s->clu, lab, inv);
		}

#ifdef EMPH_NEUTRAL		/* Emphasise neutral axis, like CIE94 does */
		{
			double c;		/* Chromanance */

			c = sqrt(lab[1] * lab[1] + lab[2] * lab[2]);	/* Compute chromanance */

//			c = 2.6624 / (1.0 + 0.013 * c);		/* Full strength scale factor */
			c = 3.0 / (1.0 + 0.03 * c);			/* Full strength scale factor */
			c = 1.0 + s->nemph * (c - 1.0);		/* Reduced strength scale factor */

			lab[1] *= c;			/* scale a & b */
			lab[2] *= c;
		}
#endif

		/* Dark/Light emphasis */
		/* This doesn't actually match how demph is applied to device values... */
		if (s->idemph != 1.0) {
			lab[0] = 100.0 * spow(lab[0]/100.0, s->idemph);
		}

		/* Copy Lab values to output */
		for (e = 0; e < (s->di < 3 ? s->di : 3); e++)
			out[e] = lab[e];

		/* Lookup perceptual linearised auxiliary values (channels beyond 3, i.e. K) */
		for (e = 0; e < (s->di-3); e++) {
			co cc;
			cc.p[0] = inv[3 + e];
			s->nlin[e]->interp(s->nlin[e], &cc);
			out[3 + e] = cc.v[0];
		}

	} else {
		/* If we have no conversion, default to linear in Device space */
		for (e = 0; e < s->di; e++)
			out[e] = 100.0 * inv[e];
			if (e == 1 || e == 2)
				out[e] -= 50.0;		/* Make it Lab like */
	}
}


/* Return the largest distance of the point outside the device gamut. */
/* This will be 0 if inside the gamut, and > 0 if outside.  */
static double
pcpt_in_dev_gamut(pcpt *s, double *d) {
	int e;
	int di = s->di;
	double tt, dd = 0.0;
	double ss = 0.0;
	double id[MXTD];

	if (s->xmask == s->nmask) {
		for (e = 0; e < s->di; e++)
			id[e] = d[e];
	} else {
		for (e = 0; e < s->di; e++)
			id[e] = 1.0 - d[e];
	}

	for (e = 0; e < di; e++) {
		ss += id[e];

		tt = 0.0 - id[e];
		if (tt > 0.0) {
			if (tt > dd)
				dd = tt;
		}
		tt = id[e] - 1.0; 
		if (tt > 0.0) {
			if (tt > dd)
				dd = tt;
		}
	}
	tt = ss - s->uilimit;
	if (tt > 0.0) {
		if (tt > dd)
			dd = tt;
	}
	return dd;
}

/* optimisation function to find device values */
/* for a target density value. */
static double efunc(void *edata, double p[]) {
	pcpt *s = (pcpt *)edata;
	int e, di = s->di;
	double rv, xyz[3], den[4];

//printf("~1 efunc got dev %f %f %f %f\n",p[0],p[1],p[2],p[3]);
	pcpt_to_XYZ(s, xyz, p);		/* Convert device to XYZ */
//printf("~1 efunc got XYZ %f %f %f\n",xyz[0],xyz[1],xyz[2]);
	icx_XYZ2Tdens(den, xyz);	/* Convert XYZ to approx statusT density */
//printf("~1 efunc got density %f %f %f %f\n",den[0],den[1],den[2],den[3]);

//printf("~1 efunc got in_dev_gamut %f\n",pcpt_in_dev_gamut(s, p));

	/* Penalise for being out of gamut */
	rv = 5000.0 * pcpt_in_dev_gamut(s, p);

	/* Error to density target */
	{
		double ss = 0.0;
		for (e = 0; e < 3; e++) {
			double tt;
			tt = s->den[e] - den[e];
			ss += tt * tt;
		}
		rv += ss;
//printf("~1 efunc target den %f %f %f, err = %f, toterr %f\n",s->den[0],s->den[1],s->den[2],ss, rv);
	}

	{
		/* Minimise all channels beyond the */
		/* (assumed) first primary 3, but don't count black. */
		/* Minimise all channels except black if nchan >= 4 and uniform target */
		double ss = 0.0;

		for (e = 0; e < di; e++) {
			double tt = 0.0;

			if (di >= 4 && s->uniform && e < 3 && e != s->kchan)
				tt = p[e];			/* Minimise primary non-black if uniform */
//			else if (!s->uniform && (e < 3 || e == s->kchan))
//				tt = p[e];			/* Minimise sum of primaries & black if uniform */
			else if (e >= 3 && e != s->kchan)
				tt = 3.0 * p[e]; 	/* Suppress non-primary, non-black */

			ss += tt;
		}
		rv += 1.5 * ss * ss;
//printf("~1 efunc sum err = %f, toterr %f\n",ss, rv);
	}

//printf("~1 returning %f\n",rv);
	return rv;
}

/* Given target CMY densities, return a suitable device value */ 
static void
pcpt_den_to_dev(pcpt *s, double *out, double *in) {
	int e, di = s->di;
	double tt, sr[MXTD];	/* Search radius */

//printf("\n");
//printf("~1 targen density = %f %f %f\n",in[0],in[1],in[2]);
//printf("~1 di = %d, ilimit = %f\n",s->di,s->ilimit);

	for (e = 0; e < 3; e++)
		s->den[e] = in[e];

	for (e = 0; e < di; e++) {
		sr[e] = 0.5;			/* Device space search radius */
		out[e] = 0.5;
	}

	if (fabs(in[0] - in[1]) < 0.1
	 && fabs(in[0] - in[2]) < 0.1
	 && fabs(in[1] - in[2]) < 0.1) {
		s->uniform = 1;
//printf("~1 uniform set\n");
	} else
		s->uniform = 0;

	if (powell(&tt, di, out, sr,  0.0001, 2000, efunc, (void *)s, NULL, NULL) != 0 || tt >= 50000.0) {
		error("targen: powell failed, tt = %f\n",tt);
	}

	/* Filter out silly values */
	for (e = 0; e < di; e++) {
		if (out[e] < 0.001)
			out[e] = 0.0;
		else if (out[e] > 0.999)
			out[e] = 1.0;
	}
//printf("~1 returning device values %f %f %f\n",out[0],out[1],out[2]);
}

/* Optimisation function to find device values */
/* for a target Lab value. */
static double efunc2(void *edata, double p[]) {
	pcpt *s = (pcpt *)edata;
	int e, di = s->di;
	double rv, lab[3];

//printf("~1 efunc2 got dev %f %f %f %f\n",p[0],p[1],p[2],p[3]);
//printf("~1 efunc2 got dev %f %f %f %f %f %f\n",p[0],p[1],p[2],p[3],p[4],p[5]);

	pcpt_to_rLab(s, lab, p);		/* Convert device to rLab */
//printf("~1 efunc2 got Lab %f %f %f\n",lab[0],lab[1],lab[2]);

//printf("~1 efunc2 got in_dev_gamut %f\n",pcpt_in_dev_gamut(s, p));

	/* Penalise for being out of gamut */
	rv = 5000.0 * pcpt_in_dev_gamut(s, p);

	/* Error to Lab target */
	{
		double ss = 0.0;
		for (e = 0; e < 3; e++) {
			double tt;
			tt = s->den[e] - lab[e];
			ss += tt * tt;
		}
		rv += ss;
//printf("~1 efunc2 target Lab %f %f %f, err = %f, toterr %f\n",s->den[0],s->den[1],s->den[2],ss, rv);
	}

	{
		int f;

		/* Minimise all channels except K, and especially any */
		/* beyond the first primary 3 or 4. */
		double ss = 0.0;

		if ((s->nmask & ICX_CMYK) == ICX_CMYK)
			f = 4;
		else 
			f = 3;
		for (e = 0; e < di; e++) {
			if (e >= f)
				ss += 10.0 * p[e]; 	/* Suppress non-primary */
			else if (e < 3)
				ss += 0.05 * p[e]; 	/* Suppress first 3 primary slightly */
		}
		rv += ss * ss;
//printf("~1 efunc2 sum err = %f, toterr %f\n",ss, rv);
	}

//printf("~1 efunc2 returning %f\n\n",rv);
	return rv;
}

/* Given target Lab densities, return a suitable device value */ 
static void
pcpt_rLab_to_dev(pcpt *s, double *out, double *in) {
	int e, di = s->di;
	double tt, sr[MXTD];	/* Search radius */

//printf("\n");
//printf("#######################3\n");
//printf("~1 targen Lab = %f %f %f\n",in[0],in[1],in[2]);
//printf("~1 di = %d, ilimit = %f\n",s->di,s->ilimit);

	for (e = 0; e < 3; e++)
		s->den[e] = in[e];

	for (e = 0; e < di; e++) {
		sr[e] = 0.5;			/* Device space search radius */
		out[e] = 0.5;
	}

	if (powell(&tt, di, out, sr,  0.0001, 2000, efunc2, (void *)s, NULL, NULL) != 0 || tt >= 50000.0) {
		error("targen: powell failed, tt = %f\n",tt);
	}

	/* Filter out silly values */
	for (e = 0; e < di; e++) {
		if (out[e] <= 0.005)
			out[e] = 0.0;
		else if (out[e] >= 0.995)
			out[e] = 1.0;
	}
//printf("~1 returning device values %f %f %f\n",out[0],out[1],out[2]);
}

/* Callback to setup s->nlin[e] extra channel (i.e. K) mapping */
static void set_nlin(void *cbntx, double *out, double *in) {
	pcpt *s = (pcpt *)cbntx;	/* Object we're setting up from */
	int e, di = s->di;
	double dev[MXTD];
	double lab[3];

	/* Just input extra channel into perceptual type lookup */
	if (s->xmask == s->nmask) {
		for (e = 0; e < di; e++) 
			dev[e] = 0.0;
		dev[3 + s->e] = in[0];
	} else {						/* Fake RGB */
		for (e = 0; e < di; e++) 
			dev[e] = 1.0;
		dev[3 + s->e] = 1.0 - in[0];
	}

	if (s->luo != NULL) {
		s->luo->lookup_fwd(s->luo, lab, dev);
	} else if (s->mlu != NULL) {
		s->mlu->lookup(s->mlu, lab, dev);
		icmXYZ2Lab(&icmD50, lab, lab);
	} else  if (s->clu != NULL) {
		s->clu->dev_to_rLab(s->clu, lab, dev);
	} else {
		lab[0] = 100.0 * in[0];
	}
	if (s->idemph != 1.0) {
		double vv = lab[0];
		lab[0] = 100.0 * spow(lab[0]/100.0, s->idemph);
	}

	/* ~~~ should we make this delta lab along locus, rather than L value ??? */

	out[0] = lab[0];
}

/* Is a specific model, not default */
int pcpt_is_specific(pcpt *s) {
	if (s->luo2 != NULL || s->mlu != NULL)
		return 1;
	return 0;
}

/* Do a simple device value ink limit clip/scale, */
/* making use of calibration curves if present. */
static int pcpt_limit_ink(pcpt *s, double *inout) {
	int clipped = 0;
	
	/* If we have calibration curves, do more complex clip/scale */
	if (s->cal != NULL
	) {
//printf("~1 limit_ink: we have cal file\n");
		if (s->ilimit > 0.0 && s->ilimit < (double)s->di) {
			double rvals[MXTD];
			double tot = 0.0;
			int e;
//printf("~1  ilimit %f < di %d\n",s->ilimit, s->di);

			/* Sum linearized values converted to final raw values */
			for (e = 0; e < s->di; e++) {
				double val = inout[e];
				if (s->cal != NULL)
					val = s->cal->interp_ch(s->cal, e, val);
				rvals[e] = val;
				tot += val;
			}
			if (tot > s->ilimit) {
				/* Scale final raw values to fit within ilimit */
				/* and then convert back to linearized values */
				double scale = s->ilimit/tot;
				for (e = 0; e < s->di; e++) {
					double val = rvals[e] * scale;
					if (s->cal != NULL) {
						val = s->cal->inv_interp_ch(s->cal, e, val);
						if (val <= -1.0)
							error("calibration curve is non-invertable");
					}
					inout[e] = val;
				}
				clipped = 1;
			}
		}

	/* else do simple one */
	} else {
//printf("~1 limit_ink: no cal file\n");
		if (s->uilimit > 0.0 && s->uilimit < (double)s->di) {
			double tot = 0.0;
			int e;

			for (e = 0; e < s->di; e++)
				tot += inout[e];
//printf("~1  uilimit %f < di %d, tot = %f\n",s->uilimit, s->di,tot);
			if (tot > s->uilimit) {
				double scale = s->uilimit/tot;
				for (e = 0; e < s->di; e++)
					inout[e] *= scale;
				clipped = 1;
			}
		}
	}
	return clipped;
}

/* Free the pcpt */
static void pcpt_del(pcpt *s) {

	if (s != NULL) {
		int e;

		if (s->luo != NULL) {
			s->luo->del(s->luo);
			s->luo2->del(s->luo2);
			s->icco->del(s->icco);
			s->fp->del(s->fp);
		}
		if (s->mlu != NULL) {
			s->mlu->del(s->mlu);
		}
		if (s->clu != NULL) {
			s->clu->del(s->clu);
		}
		for (e = 0; e < (s->di-3); e++) {
			if (s->nlin[e] != NULL)
				s->nlin[e]->del(s->nlin[e]);
		}
		
		if (s->cal != NULL)
			s->cal->del(s->cal);

		free(s);
	}
}

/* Create a pcpt conversion class */
pcpt *new_pcpt(
char *profName,			/* ICC or MPP profile path, NULL for default, "none" for linear */
char *calName,			/* NULL for default/no override, "none" for overide none */
inkmask xmask,			/* external xcolorants mask */
inkmask nmask,			/* internal xcolorants mask */
double *ilimit,			/* (final raw) device ink sum limit (scale 1.0) input and return, -1 if default */
double *uilimit,		/* (linearized) device ink sum limit (scale 1.0) input and return, -1 if default */
double nemph,			/* Neutral emphasis, 0.0 - 1.0. < 0.0 for default == CIE94 */
double demph,			/* Dark emphasis, 1.0 - 4.0. < 0.0 for default == none */
double lemph,			/* Light emphasis, 1.0 - 4.0. < 0.0 for default == none */
double xpow				/* Extra device power, default = none */
) {
	int e;
	icmErr err = { 0, { '\000'} };
	pcpt *s;

	if ((s = (pcpt *)calloc(1, sizeof(pcpt))) == NULL) {
		fprintf(stderr,"targen: malloc failed allocating pcpt object\n");
		exit(-1);
	}
	
	/* Initialise methods */
	s->del          = pcpt_del;
	s->is_specific  = pcpt_is_specific;
	s->dev_to_perc  = pcpt_to_nLab;
	s->dev_to_XYZ   = pcpt_to_XYZ;
	s->dev_to_rLab  = pcpt_to_rLab;
	s->den_to_dev   = pcpt_den_to_dev;
	s->rLab_to_dev  = pcpt_rLab_to_dev;
	s->limit_ink    = pcpt_limit_ink;

	s->xmask = xmask;
	s->nmask = nmask;
	s->di = icx_noofinks(nmask);

	if (nemph < 0.0)
		nemph = NEMPH_DEFAULT;
	s->nemph = nemph;

	if (demph < 0.0)
		demph = 1.0;
	s->idemph = 1.0/demph;

	if (lemph < 0.0)
		lemph = 1.0;
	s->idemph *= lemph;

	if (xpow < 0.0)
		xpow = XPOW_DEFAULT;
	s->ixpow = 1.0/xpow;

//printf("~1 new_pcpt called:\n");
 
	/* See if we have a profile */
	if (profName != NULL
	 && profName[0] != '\000'
	 && strcmp(profName, "none") != 0
	 && strcmp(profName, "NONE") != 0) {
		int rv = 0;
		
//printf("~1  we have a profile\n");
		/* Try and open the file as an ICC profile */
		if ((s->fp = new_icmFileStd_name(&err,profName,"r")) == NULL)
			error ("Can't open device profile '%s' (0x%x, '%s')",profName,err.c,err.m);
	
		if ((s->icco = new_icc(&err)) == NULL)
			error ("Creation of ICC object failed (0x%x, '%s')",err.c,err.m);
	
		if ((rv = s->icco->read(s->icco,s->fp,0)) == 0) {
			icmCSInfo ini, outi;
			icColorSpaceSignature ins, outs;	/* Type of input and output spaces */

			/* Get a conversion object for relative Lab */
			if ((s->luo = (icmLuSpace *)s->icco->get_luobj(s->icco, icmFwd, icRelativeColorimetric,
			                                 icSigLabData, icmLuOrdNorm)) == NULL) {
				if ((s->luo = (icmLuSpace *)s->icco->get_luobj(s->icco, icmFwd, icmDefaultIntent,
				                                 icSigLabData, icmLuOrdNorm)) == NULL) {
					error ("%d, %s",s->icco->e.c, s->icco->e.m);
				}
			}

			/* Get a conversion object for absolute XYZ */
			if ((s->luo2 = (icmLuSpace *)s->icco->get_luobj(s->icco, icmFwd, icAbsoluteColorimetric,
			                                 icSigXYZData, icmLuOrdNorm)) == NULL) {
				if ((s->luo2 = (icmLuSpace *)s->icco->get_luobj(s->icco, icmFwd, icmDefaultIntent,
				                                 icSigXYZData, icmLuOrdNorm)) == NULL) {
					error ("%d, %s",s->icco->e.c, s->icco->e.m);
				}
			}
		
			/* Get details of conversion (Arguments may be NULL if info not needed) */
			s->luo->spaces(s->luo, &ini, &outi, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
			ins = ini.sig;
			outs = outi.sig;

//printf("~1 xmask = 0x%x, ins = %s\n",xmask,icm2str(icmColorSpaceSignature, ins));
			if (icx_colorant_comb_match_icc(xmask, ins) == 0) {

				/* Should really see if ICC profile has ColorantTable tag, */
				/* and match them against targen specs. For now, */
				/* simply make sure the channel counts match and issue */
				/* a warning. */
				if (icx_noofinks(xmask) != icmCSSig2nchan(ins)) {
					s->luo->del(s->luo);
					s->luo = NULL;
					error("ICC profile doesn't match device!");
				} else {
					warning("Profile '%s' no. channels match, but colorant types have not been checked",profName);
				}
			}

			/* grab any device calibration curves in ICC 'targ' .ti3 */
			s->cal = xiccReadCalTag(s->icco);

//printf("~1  ICC cal = %p\n",s->cal);


		} else {	/* Not a valid ICC */
//printf("~1  ICC not valid\n");
			/* Close out the ICC profile */
			s->icco->del(s->icco);
			s->icco = NULL;
			s->fp->del(s->fp);
			s->fp = NULL;
			s->luo = NULL;
		}

		/* If we don't have an ICC lookup object, look for an MPP */
		/* and set an ink limit from that. */
		if (s->luo == NULL) {
			inkmask imask;
			double dlimit = 0.0;

//printf("~1 opeing mpp\n");
			if ((s->mlu = new_mpp()) == NULL)
				error ("Creation of MPP object failed");

			if ((rv = s->mlu->read_mpp(s->mlu, profName)) != 0)
				error ("%d, %s",rv,s->mlu->e.m);

			s->mlu->get_info(s->mlu, &imask, NULL, &dlimit, NULL, NULL, NULL, NULL, NULL);

			if (xmask != imask) {
				s->mlu->del(s->mlu);
				error("MPP profile doesn't match device!");
			}
			if (*ilimit < 0.0 && dlimit > 0.0)	 { /* If not user specified, use MPP inklimit */
				*ilimit = dlimit + 0.1;
//printf("~1  mpp set ilimit %f\n",*ilimit);
			}
		}
	}

	/* Fall back on an xcolorants model */
	if (s->luo == NULL
	 && s->mlu == NULL
	 && strcmp(profName, "none") != 0
	 && strcmp(profName, "NONE") != 0) {
		if ((s->clu = new_icxColorantLu(xmask)) == NULL)
			error ("Creation of xcolorant lu object failed");
//printf("~1  using xcolorants model\n");
	}
	/* else leave pointers NULL */

	/* If we have an override .cal file, load it. */
	if (calName != NULL && calName[0] != '\000') {
		if (strcmp(profName, "none") != 0
		 && strcmp(profName, "NONE") != 0
		 && (s->cal = new_xcal()) != NULL) {
			if (s->cal->read(s->cal, calName) != 0) {
				s->cal->del(s->cal);
				s->cal = NULL;
			}
//else printf("~1  found cal file\n");
		}
	}


	/* Set the default ink limits from the ICC if not set by user or MPP */
	if (*ilimit < 0.0 && s->icco != NULL) {
		icxCalCBctx cctx = { 0 };

		if (s->cal != NULL) {
			cctx.cal = s->cal;
			*ilimit = s->icco->get_tac(s->icco, NULL, xiccCalCallback_void, &cctx);
			*uilimit = s->icco->get_tac(s->icco, NULL, NULL, NULL);
//printf("~1  icc set cal ilimit %f uilimit %f\n",*ilimit,*uilimit);
		} else
		{
//printf("~1  icc set ilimit %f uilimit %f\n",*ilimit,*uilimit);
			*uilimit = *ilimit = s->icco->get_tac(s->icco, NULL, NULL, NULL);
		}
		*ilimit += 0.1;		/* + 10% */
		*uilimit += 0.1;	/* + 10% */

	} else {

		/* Set a default ink limit if not set by user, ICC or MPP */
		if (*ilimit < 0.0) {
			*uilimit = (double)s->di;	/* Default to no limit */
			*ilimit = *uilimit;
//printf("~1  set default ilimit %f uilimit %f\n",*ilimit,*uilimit);
		}

		/* If not set by ICC and any .cal, convert ilimit to uilimit using cal */
		if ((s->cal != NULL) && *ilimit >= 0.0 && *ilimit < (double)s->di) {
			*uilimit = icxMaxUnderlyingLimit(s->cal, *ilimit);
//printf("~1  recompute cal uilimit %f\n",*uilimit);
		}
	}

	s->ilimit  = *ilimit;
	s->uilimit = *uilimit;

	if (s->di > 1)
		s->kchan = icx_ink2index(xmask, ICX_BLACK);
	else
		s->kchan = -1;

	/* Create extra chanel perceptual linearisation lookups */
	for (e = 0; e < (s->di-3); e++) {
		double inmin = 0.0, inmax = 1.0;
		double outmax = 100.0;
		int gres = 256;

		if ((s->nlin[e] = new_rspl(RSPL_NOFLAGS, 1, 1)) == NULL)
			error("RSPL creation failed");

		s->e = e;	/* Chanel to set */
		s->nlin[e]->set_rspl(s->nlin[e], 0, s, set_nlin,
		                     &inmin, &inmax, &gres, &inmax, &outmax);
	}

	return s;
}

/* ------------------------------------ */

/*

  Flags used:

         ABCDEFGHIJKLMNOPQRSTUVWXYZ
  upper  .... ....   ... .. ......  
  lower  ....... .  ... ..... ..    

*/

void
usage(int level, char *diag, ...) {
	int i;
	fprintf(stderr,"Generate Target deviceb test chart color values, Version %s\n",ARGYLL_VERSION_STR);
	fprintf(stderr,"Author: Graeme W. Gill, licensed under the AGPL Version 3\n");
	fprintf(stderr,"usage: targen [options] outfile\n");
	if (diag != NULL) {
		va_list args;
		fprintf(stderr,"  Diagnostic: ");
		va_start(args, diag);
		vfprintf(stderr, diag, args);
		va_end(args);
		fprintf(stderr,"\n");
	}
	fprintf(stderr," -v [level]      Verbose mode [optional level 1..N]\n");
	fprintf(stderr," -d col_comb     choose colorant combination from the following:\n");
	for (i = 0; ; i++) {
		char *desc; 
		if (icx_enum_colorant_comb(i, &desc) == 0)
			break;
		fprintf(stderr,"                 %d: %s\n",i,desc);
	}
	fprintf(stderr," -D colorant     Add or delete colorant from combination:\n");
	if (level == 0)
		fprintf(stderr,"                 (Use -?? to list known colorants)\n");
	else {
		fprintf(stderr,"                 %d: %s\n",0,"Additive");
		for (i = 0; ; i++) {
			char *desc; 
			if (icx_enum_colorant(i, &desc) == 0)
				break;
			fprintf(stderr,"                 %d: %s\n",i+1,desc);
		}
	}
	fprintf(stderr," -G               Generate good optimized points rather than Fast\n");
	fprintf(stderr," -e patches       White test patches (default 4)\n");
	fprintf(stderr," -B patches       Black test patches (default 4 Grey/RGB, else 0)\n");
	fprintf(stderr," -s steps         Single channel steps (default grey 50, color 0)\n");
	fprintf(stderr," -g steps         Grey axis RGB or CMY steps (default 0)\n");
	fprintf(stderr," -n steps         Neutral axis steps (based on profile, default 0)\n");
	fprintf(stderr," -m steps         Multidimensional device space cube steps (default 0)\n");
	fprintf(stderr," -M steps         Multidimensional device space cube surface steps (default 0)\n");
	fprintf(stderr," -b steps         Multidimensional body centered cubic steps (default 0)\n");
#ifdef COMMPLUS     /* Commercial+ */
	fprintf(stderr," -H size          N-Color test chart, size 1, 2 or 3 (default 1)\n");
#endif
	fprintf(stderr," -f patches       Add iterative & adaptive full spread patches to total (default grey 0, color 836)\n");
	fprintf(stderr,"                  Default is Optimised Farthest Point Sampling (OFPS)\n");
	fprintf(stderr,"  -t              Use incremental far point for full spread\n");
	fprintf(stderr,"  -r              Use device space random for full spread\n");
	fprintf(stderr,"  -R              Use perceptual space random for full spread\n");
	fprintf(stderr,"  -q              Use device space-filling quasi-random for full spread\n");
	fprintf(stderr,"  -Q              Use perceptual space-filling quasi-random for full spread\n");
	fprintf(stderr,"  -i              Use device space body centered cubic grid for full spread\n");
	fprintf(stderr,"  -I              Use perceptual space body centered cubic grid for full spread\n");
	fprintf(stderr,"  -a angle        Simplex grid angle 0.0 - 0.5 for B.C.C. grid, default %f\n",DEFANGLE);
	fprintf(stderr,"  -A adaptation   Degree of adaptation of OFPS 0.0 - 1.0 (default 0.1, -c profile uses 1.0)\n");
/* Research options: */
/*	fprintf(stderr,"  -A pPERCWGHT    Device (0.0) ... Perceptual (1.0) weighting\n"); */
/*	fprintf(stderr,"  -A cCURVEWGHT   Curvature weighting  0.0 = none ... "); */
	fprintf(stderr," -l ilimit        Total ink limit in %% (default = none)\n");
	fprintf(stderr," -T ilimit        Text and space total ink limit in %% (default = same as -l)\n");
	fprintf(stderr," -p power         Optional power-like value applied to all device values.\n");
	fprintf(stderr," -c profile       Optional device ICC or MPP pre-conditioning profile filename\n");
	fprintf(stderr,"                  (Use \"none\" to turn off any conditioning)\n");
	fprintf(stderr," -C cal           Optional .cal filename that overrides any .cal in ICC 'targ' .ti3\n");
	fprintf(stderr,"                  (Use \"none\" to disable .cal use in estimating ink limit)\n");
	fprintf(stderr," -N emphasis      Degree of neutral axis patch concentration 0.0-1.0 (default %.2f)\n",NEMPH_DEFAULT);
	fprintf(stderr," -V emphasis      Degree of dark region patch concentration 1.0-4.0 (default %.2f = none)\n",1.0);
	fprintf(stderr," -F L,a,b,rad     Filter out samples outside Lab sphere.\n");
	fprintf(stderr," -O               Don't re-order display RGB patches for minimum delay\n");
	fprintf(stderr," -U               Don't filter out duplicate patches\n");
#ifdef VRML_DIAG
	fprintf(stderr," -w               Dump diagnostic outfilel%s file (Lab locations)\n",vrml_ext());
	fprintf(stderr," -W               Dump diagnostic outfiled%s file (Device locations)\n",vrml_ext());
#endif /* VRML_DIAG */
	fprintf(stderr," outfile          Base name for output(.ti1)\n");
	exit(1);
}

/* Test if outside filter sphere. Return nz if it is */
int dofilt(
	pcpt *pdata,		/* Perceptual conversion routine */
	double *filt,		/* Filter sphere definition */
	double *dev			/* Device values to check */
) {
	int i;
	double Lab[3], rr;
	pdata->dev_to_rLab(pdata, Lab, dev);
	for (rr = 0.0, i = 0; i < 3; i++) {
		double tt = Lab[i] - filt[i];
		rr += tt * tt;
	}
	if (rr > (filt[3] * filt[3])) {
//printf("~1 rejecting rad %f of %f %f %f <=> %f %f %f\n",sqrt(rr),Lab[0],Lab[1],Lab[2],filt[0],filt[1],filt[2]);
		return 1;
	}
	return 0;
}


static double disprespt(cgats *pp, int p1, int p2);

int main(int argc, char *argv[]) {
	int i, j, k;
	int fa, nfa, mfa;		/* current argument we're looking at */
	int verb = 0;			/* Verbose flag */
#ifdef VRML_DIAG
	int dumpvrml = 0;		/* Dump diagnostic VRML/X3D file */
#endif /* VRML_DIAG */
	inkmask xmask = 0;		/* External ink mask combination */
	inkmask nmask = 0;		/* Working ink mask combination (ie. CMY for printer external sRGB) */
	int di = 0;				/* Output dimensions */
	char *ident;			/* Ink combination identifier (includes possible leading 'i') */
	int good = 0;			/* 0 - fast, 1 = good */
	int esteps = -1;		/* White color patches */
	int Bsteps = -1;		/* Black color patches */
	int ssteps = -1;		/* Single channel steps */
	double xpow = 1.0;		/* Power to apply to all device values created */
	int gsteps = -1;		/* Composite grey wedge steps */
	int nsteps = -1;		/* Neutral wedge steps */
	int msteps = 0;			/* Regular grid multidimensional steps */
	int msurf = 0;			/* If nz, make msteps just on device surface */
	int bsteps = 0;			/* Regular body centered cubic grid multidimensional steps */
#ifdef COMMPLUS     /* Commercial+ */
	int Hsize = 0;			/* Structured N-Channel chart size 1,2 or 3 */
#endif
	int fsteps = -1;		/* Fitted Multidimensional patches */
	int uselat = 0;			/* Use incremental far point alg. for full spread points */
	int userand = 0;		/* Use random for full spread points, 2 = perceptual */
	int useqrand = 0;		/* Use sobol for full spread points, 2 = perceptual */
	int usedsim = 0;		/* Use device space simplex grid */
	int usepsim = 0;		/* Use perceptual space simplex grid */
	double simangle = DEFANGLE;	/* BCC grid angle */
	double dadapt = -2.0;	/* Degree of iterative adaptation */
	double perc_wght = 0.0;	/* Perceptual weighting */
	double curv_wght = 0.0;	/* Curvature weighting */
	double ilimit = -1.0;	/* Ink limit (raw final space, scale 1.0) (default none) */
	double uilimit = -1.0;	/* Underlying (linearized space, scale 1.0) ink limit */
	double tilimit = -1.0;	/* Text and spacer ink limit (raw final, scale 1.0) (default none) */
	double utilimit = -1.0;	/* Text and spacer ink limit (linearized space, scale 1.0) */
	double nemph = NEMPH_DEFAULT;
	double demph = 1.0;		/* Dark emphasis. Default = none */
	double lemph = 1.0;		/* Light emphasis (inverse of demph). Default = none */
	int dontdedupe = 0;		/* Don't filter duplicate samples */
	int dontreorder = 0;	/* Don't re-order RGB display patches for min delay */
	int filter = 0;			/* Filter values outside given sphere */
	double filt[4] = { 50,0,0,0 };	
	static char fname[MAXNAMEL+1] = { 0 };		/* Output file base name */
	static char pname[MAXNAMEL+1] = { 0 };		/* Device profile name */
	static char cname[MAXNAMEL+1] = { 0 };		/* Device calibration file name */
	static char wdname[MAXNAMEL+1] = { 0 };		/* Device diagnostic .wrl/.x3d name */
	static char wlname[MAXNAMEL+1] = { 0 };		/* Lab diagnostic .wrl/.x3d name */
	char buf[500];			/* Genaral use text buffer */
	int id = 1;				/* Sample ID */
	time_t clk = time(0);
	struct tm *tsp = localtime(&clk);
	char *atm = asctime(tsp); /* Ascii time */
	cgats *pp;				/* cgats structure */
	long stime,ttime;
	pcpt *pdata;			/* Space linearisation callback struct */
	pcpt *tpdata;			/* Text and spacer Space linearisation callback struct */
	fxpos *fxlist = NULL;	/* Fixed point list for full spread */
	int fxlist_a = 0;		/* Fixed point list allocation */
	int fxno = 0;			/* The number of fixed points */


#ifdef NUMSUP_H
	error_program = "targen";
#endif
	check_if_not_interactive();

	if (argc <= 1)
		usage(0,"Too few arguments, got %d expect at least %d",argc-1,1);

	/* Process the arguments */
	mfa = 1;        /* Minimum final arguments */
	for (fa = 1;fa < argc;fa++) {
		nfa = fa;					/* skip to nfa if next argument is used */
		if (argv[fa][0] == '-') {	/* Look for any flags */
			char *na = NULL;		/* next argument after flag, null if none */

			if (argv[fa][2] != '\000')
				na = &argv[fa][2];		/* next is directly after flag */
			else {
				if ((fa+1+mfa) < argc) {
					if (argv[fa+1][0] != '-') {
						nfa = fa + 1;
						na = argv[nfa];		/* next is seperate non-flag argument */
					}
				}
			}

			if (argv[fa][1] == '?' || argv[fa][1] == '-') {
				if (argv[fa][2] == '?' || argv[fa][2] == '-')
					usage(1, "Extended usage requested");
				usage(0, "Usage requested");
			}

			else if (argv[fa][1] == 'v') {
				verb = 1;
				if (na != NULL && na[0] >= '0' && na[0] <= '9') {
					verb = atoi(na);
					fa = nfa;
				}
			}

			/* Select the ink enumeration */
			else if (argv[fa][1] == 'd') {
				fa = nfa;
				if (na == NULL) usage(0,"Expect argument after -d");
				i = atoi(na);
				if (i == 0 && na[0] != '0')
					usage(0,"Expect number argument after -d");
				if ((xmask = icx_enum_colorant_comb(i, NULL)) == 0)
					usage(0,"Argument to -d is not recognized");
			}
			/* Toggle the colorant in ink combination */
			else if (argv[fa][1] == 'D') {
				int tmask;
				fa = nfa;
				if (na == NULL) usage(0,"Expect argument after -D");
				i = atoi(na);
				if (i == 0 && na[0] != '0')
					usage(0,"Expect number argument after -D");
				if (i == 0)
					tmask = ICX_ADDITIVE;
				else
					if ((tmask = icx_enum_colorant(i-1, NULL)) == 0)
						usage(0,"Argument to -D is not recognized");
				xmask ^= tmask;
			}
			/* Good rather than fast */
			else if (argv[fa][1] == 'G') {
				good = 1;
			}
			/* White color patches */
			else if (argv[fa][1] == 'e') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -e");
				if ((tt = atoi(na)) >= 0)
					esteps = tt;
				fa = nfa;
			}
			/* Black color patches */
			else if (argv[fa][1] == 'B') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -B");
				if ((tt = atoi(na)) >= 0)
					Bsteps = tt;
				fa = nfa;
			}
			/* Individual chanel steps */
			else if (argv[fa][1] == 's') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -s");
				if ((tt = atoi(na)) >= 0)
					ssteps = tt;
				fa = nfa;
			}
			/* PCS based neutral wedge steps */
			else if (argv[fa][1] == 'n') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -n");
				if ((tt = atoi(na)) >= 0)
					nsteps = tt;
				fa = nfa;
			}
			/* RGB or CMY grey wedge steps */
			else if (argv[fa][1] == 'g') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -g");
				if ((tt = atoi(na)) >= 0)
					gsteps = tt;
				fa = nfa;
			}
			/* Multidimentional cube steps */
			else if (argv[fa][1] == 'm'
			      || argv[fa][1] == 'M') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -m");
				if ((tt = atoi(na)) >= 0) {
					msteps = tt;
					if (msteps == 1)
						msteps = 2;
				}
				if (argv[fa][1] == 'M')
					msurf = 1;
				fa = nfa;
			}
			/* Multidimentional body centered cube steps */
			else if (argv[fa][1] == 'b') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -b");
				if ((tt = atoi(na)) >= 0) {
					bsteps = tt;
					if (bsteps == 1)
						bsteps = 2;
				}
				fa = nfa;
			}
#ifdef COMMPLUS     /* Commercial+ */
			/* Structured N-Channel chart */
			else if (argv[fa][1] == 'H') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -H");
				tt = atoi(na);
				if (tt >= 1 && tt <= 3) {
					Hsize = tt;
				} else {
					usage(0,"Expect -H argument is 1, 2, or 3, not '%s'",na);
				}
				fa = nfa;
			}
#endif
			/* Full even spread Multidimentional patches */
			else if (argv[fa][1] == 'f') {
				int tt;
				if (na == NULL) usage(0,"Expect argument after -f");
				if ((tt = atoi(na)) >= 0)
					fsteps = tt;
				fa = nfa;
			}

			/* Use incremental far point algorithm for full spread */
			else if (argv[fa][1] == 't') {
				uselat = 1;
				userand = 0;
				useqrand = 0;
				usedsim = 0;
				usepsim = 0;
			}

			/* Random requested */
			else if (argv[fa][1] == 'r'
				  || argv[fa][1] == 'R') {
				uselat = 0;
				if (argv[fa][1] == 'R')
					userand = 2;
				else
					userand = 1;
				useqrand = 0;
				usedsim = 0;
				usepsim = 0;
			}

			/* Space filling quasi-random requested */
			else if (argv[fa][1] == 'q'
				  || argv[fa][1] == 'Q') {
				uselat = 0;
				userand = 0;
				if (argv[fa][1] == 'Q')
					useqrand = 2;
				else
					useqrand = 1;
				usedsim = 0;
				usepsim = 0;
			}


			/* Device simplex grid requested */
			else if (argv[fa][1] == 'i') {
				uselat = 0;
				userand = 0;
				useqrand = 0;
				usedsim = 1;
				usepsim = 0;
			}

			/* Perceptual simplex grid requested */
			else if (argv[fa][1] == 'I') {
				uselat = 0;
				userand = 0;
				useqrand = 0;
				usedsim = 0;
				usepsim = 1;
			}

			/* Simplex grid angle */
			else if (argv[fa][1] == 'a') {
				if (na == NULL) usage(0,"Expect argument after -a");
				simangle = atof(na);
				fa = nfa;
			}

			/* Degree of iterative adaptation */
			else if (argv[fa][1] == 'A') {
				if (na == NULL) usage(0,"Expected argument to average deviation flag -A");
				if (na[0] == 'p') {			/* (relative, for verification) */
					perc_wght = atof(na+1);
					if (perc_wght < 0.0 || perc_wght > 1.0)
						usage(0,"Perceptual weighting argument %f to '-Ap' must be between 0.0 and 1.0",perc_wght);
					dadapt = -1.0;
				} else if (na[0] == 'c') {	/* (absolute, for testing) */
					curv_wght = atof(na+1);
					if (curv_wght < 0.0 || curv_wght > 100.0)
						usage(0,"Curvature weighting argument %f to '-Ac' must be between 0.0 and 100.0",curv_wght);
					dadapt = -1.0;
				} else {
					dadapt = atof(na);
					if (dadapt < 0.0 || dadapt > 1.0)
						usage(0,"Average Deviation argument %f must be between 0.0 and 1.0",dadapt);
				}
				fa = nfa;
			}

			/* Ink limit percentage */
			else if (argv[fa][1] == 'l') {
				double tt;
				if (na == NULL) usage(0,"Expect argument after -l");
				if ((tt = atof(na)) > 0.0) {
					uilimit = ilimit = 0.01 * tt;
					if (tilimit < 0.0)
						utilimit = tilimit = uilimit; 
				}
				fa = nfa;
			}

			/* Text and space ink limit percentage */
			else if (argv[fa][1] == 'T') {
				double tt;
				if (na == NULL) usage(0,"Expect argument after -l");
				if ((tt = atof(na)) > 0.0)
					utilimit = tilimit = 0.01 * tt;
				fa = nfa;
			}

			/* Extra device power-like to use */
			else if (argv[fa][1] == 'p') {
				double tt;
				if (na == NULL) usage(0,"Expect argument after -p");
				if ((tt = atof(na)) > 0.0)
					xpow = tt;
				fa = nfa;
			}

			/* ICC profile for perceptual linearisation */
			else if (argv[fa][1] == 'c') {
				if (na == NULL) usage(0,"Expect argument after -c");
				strncpy(pname,na,MAXNAMEL-1); pname[MAXNAMEL-1] = '\000';
				fa = nfa;
			}

			/* .cal file that overrides any .cal in profile .ti3 'targ' data */
			else if (argv[fa][1] == 'C') {
				if (na == NULL) usage(0,"Expect argument after -c");
				strncpy(cname,na,MAXNAMEL-1); cname[MAXNAMEL-1] = '\000';
				fa = nfa;
			}

			/* Degree of neutral axis emphasis */
			else if (argv[fa][1] == 'N') {
				if (na == NULL) usage(0,"Expected argument to neutral emphasis flag -N");
				nemph = atof(na);
				if (nemph < 0.0 || nemph > 10.0)
					usage(0,"Neautral weighting argument %f to '-N' is out of range",nemph);
				fa = nfa;
			}

			/* Degree of dark region emphasis */
			else if (argv[fa][1] == 'V') {
				if (na == NULL) usage(0,"Expected argument to dark emphasis flag -V");
				demph = atof(na);
				if (demph < 1.0 || demph > 4.0)
					usage(0,"Dark weighting argument %f to '-V' is out of range",demph);
				fa = nfa;
			}

			/* Filter out samples outside given sphere */
			else if (argv[fa][1] == 'F') {
				if (na == NULL) usage(0,"Expect argument after -F");
				if (sscanf(na, " %lf,%lf,%lf,%lf ",&filt[0], &filt[1], &filt[2], &filt[3]) != 4)
					usage(0,"Argument to -F '%s' isn't correct",na);
				filter = 1;
				fa = nfa;
			}

			/* Don't re-order RGB display patches for best speed */
			else if (argv[fa][1] == 'O') {
				dontreorder = 1;
			}

			/* Don't filter out redundant patches */
			else if (argv[fa][1] == 'U') {
				dontdedupe = 1;
			}

#ifdef VRML_DIAG
			else if (argv[fa][1] == 'w')		/* Lab */
				dumpvrml |= 1;
			else if (argv[fa][1] == 'W')		/* Device */
				dumpvrml |= 2;
#endif /* VRML_DIAG */
			/* Extra flags */
			else if (argv[fa][1] == 'Y') {
				fa = nfa;
				if (na == NULL)
					usage(0,"Parameter expected after -Y");
				{
					usage(0,"-Y parameter '%c' not recognised",na[0]);
				}
			}

			else 
				usage(0,"Unknown flag '%c'",argv[fa][1]);
		}
		else
			break;
	}

	/* Get the file name argument */
	if (fa >= argc || argv[fa][0] == '-') usage(0,"Expect file base name argument");
	strncpy(fname,argv[fa],MAXNAMEL-4); fname[MAXNAMEL-4] = '\000';
	strcat(fname,".ti1");

	strncpy(wdname,argv[fa],MAXNAMEL-5); wdname[MAXNAMEL-5] = '\000';
	strcat(wdname,"d");

	strncpy(wlname,argv[fa],MAXNAMEL-5); wlname[MAXNAMEL-5] = '\000';
	strcat(wlname,"l");


	/* Set default colorant combination as CMYK */
	if (xmask == 0)
		xmask = ICX_CMYK;
	
	nmask = xmask;

	/* Deal with fake printer RGB, where we use CMY internally and invert all */
	/* the resulting device values. */
	if (xmask & ICX_INVERTED) {
		if (xmask != ICX_IRGB)
			error("Don't know how to deal with inverted colorant combination 0x%x\n",xmask);
		nmask = ICX_CMY;	/* Internally treat it as CMY and invert the result */
	}

	ident = icx_inkmask2char(xmask, 1); 
	di = icx_noofinks(nmask);	/* Lookup number of dimensions */
	stime = clock();

	/* Implement some defaults */
	if (esteps < 0)
		esteps = 4;
	if (gsteps < 0)
		gsteps = 0;
	if (nsteps < 0)
		nsteps = 0;

	if (Bsteps < 0) {
		if (xmask == ICX_W || xmask == ICX_K || xmask == ICX_RGB || xmask == ICX_IRGB)
			Bsteps = 4;
		else
			Bsteps = 0; 
	}

	if (di == 1) {
		if (ssteps < 0)
			ssteps = 50;
		if (fsteps < 0)
			fsteps = 0;
	} else {
		if (ssteps < 0)		/* Defaults */
			ssteps = 0;
		if (fsteps < 0)
			fsteps = 836;
	}

	/* Do some sanity checking */
	if (di == 1) {
		if (ssteps == 0 && fsteps == 0 && msteps == 0 && bsteps == 0)
			error ("Must have some Gray steps");
		if (gsteps > 0) {
			warning ("Composite grey steps ignored for monochrome output");
			gsteps = 0;
		}
		if (nsteps > 0) {
			warning ("Neutral steps ignored for monochrome output");
			nsteps = 0;
		}
	} else if (di == 3) {
			if (ssteps == 0 && fsteps == 0 && msteps == 0 && bsteps == 0
			 && gsteps == 0 && nsteps == 0)
				error ("Must have some single or multi dimensional RGB or CMY steps");
	} else {
		if (ssteps == 0 && fsteps == 0 && msteps == 0 && bsteps == 0
		    && gsteps == 0 && nsteps == 0)
			error ("Must have some single or multi dimensional steps");
	}

#ifdef COMMPLUS     /* Commercial+ */
	if (Hsize > 0) {
		if (esteps < 4)
			esteps = 4;		/* Min. 4 white patches */
		Bsteps = 0;			/* No black color patches */
		ssteps = 0;			/* No extra single channel steps */
		gsteps = 0;			/* No extra composite grey wedge steps */
		nsteps = 0;			/* No extra neutral wedge steps */
		msteps = 0;			/* No extra regular grid multidimensional steps */
		bsteps = 0;			/* No extra regular body centered cubic grid multidimensional steps */
		fsteps = 0;			/* No full spread patches */
	}
#endif

	/* Set default adapation level */
	if (dadapt < -1.5) {		/* Not set by user */
		if (pname[0] != '\000')
			dadapt = 1.0;
		else
			dadapt = 0.1;
	}

	/* Counteract natural dark shift of patches if auxiliary black is used */
	/* (BUT fully copensate only if adaptation is high !) */
	if ((di > 3 && xmask & ICX_K) != 0) {
		lemph = 2.0;			/* Noticably lighten, but not extreme... */
		if (dadapt < 0.5)
			dadapt = 0.5;		/* Partial compensation */
	}

	/* Deal with ICC, MPP or fallback profile */
	if ((pdata = new_pcpt(pname, cname,
		                  xmask, nmask, &ilimit, &uilimit,
		                  nemph, demph, lemph, xpow)) == NULL) {
		error("Perceptual lookup object creation failed");
	}

	if ((tpdata = new_pcpt(pname, cname,
		                  xmask, nmask, &tilimit, &utilimit,
		                  nemph, demph, lemph, xpow)) == NULL) {
		error("Perceptual lookup object creation failed");
	}

	if (verb) {
		printf("%s test chart\n",ident);

#ifdef COMMPLUS     /* Commercial+ */
		if (Hsize > 0)
			printf("N-channel structured chart size = %d\n",Hsize);
#endif
		if (esteps > 0)
			printf("White patches = %d\n",esteps);
		if (Bsteps > 0)
			printf("Black patches = %d\n",Bsteps);
		if (ssteps > 0)
			printf("Single channel steps = %d\n",ssteps);
		if (gsteps > 0)
			printf("Composite Grey steps = %d\n",gsteps);
		if (nsteps > 0)
			printf("Neutral steps = %d\n",nsteps);
		if (fsteps > 0)
			printf("Full spread patches = %d\n",fsteps);
		if (msteps > 0) {
			if (msurf)
				printf("Multi-dimention cube surface steps = %d\n",msteps);
			else
				printf("Multi-dimention cube steps = %d\n",msteps);
		}
		if (bsteps > 0)
			printf("Multi-dimention body centered cube steps = %d\n",bsteps);
		if (ilimit >= 0.0 || uilimit >= 0.0) {
			if (ilimit == uilimit)
				printf("Ink limit = %.1f%%\n",uilimit * 100.0);
			else
				printf("Ink limit = %.1f%%, final raw limit %.1f%%\n",uilimit * 100.0, ilimit * 100.0);
		}
		if (tilimit >= 0.0 && uilimit != utilimit) {
			if (tilimit == utilimit)
				printf("Text and spacer ink limit = %.1f%%\n",utilimit * 100.0);
				printf("Text and spacer ink limit = %.1f%%, final raw limit %.1f%%\n",utilimit * 100.0, tilimit * 100.0);
		}
		if (filter) {
			printf("Filtering out samples outside sphere at %f %f %f radius %f\n",
					filt[0], filt[1], filt[2], filt[3]);
		}
	}
	pp = new_cgats();	/* Create a CGATS structure */
	pp->add_other(pp, "CTI1"); 	/* our special type is Calibration Target Information 1 */

	pp->add_table(pp, tt_other, 0);	/* Add the first table for target points */
	pp->add_table(pp, tt_other, 0);	/* Add the second table for density pre-defined device values */
	pp->add_table(pp, tt_other, 0);	/* Add the second table for device pre-defined device values */
	pp->add_kword(pp, 0, "DESCRIPTOR", "Argyll Calibration Target chart information 1",NULL);
	pp->add_kword(pp, 1, "DESCRIPTOR", "Argyll Calibration Target chart information 1",NULL);
	pp->add_kword(pp, 2, "DESCRIPTOR", "Argyll Calibration Target chart information 1",NULL);
	pp->add_kword(pp, 0, "ORIGINATOR", "Argyll targen", NULL);
	pp->add_kword(pp, 1, "ORIGINATOR", "Argyll targen", NULL);
	pp->add_kword(pp, 2, "ORIGINATOR", "Argyll targen", NULL);
	atm[strlen(atm)-1] = '\000';	/* Remove \n from end */
	pp->add_kword(pp, 0, "CREATED",atm, NULL);

	/* Make available the aproximate white point to allow relative */
	/* interpretation of the aproximate XYZ values */
	{
		int e;
		double val[MXTD], XYZ[3];

		/* Setup device white */
		if (nmask & ICX_ADDITIVE)
			for (e = 0; e < di; e++)
				val[e] = 1.0;
		else
			for (e = 0; e < di; e++)
				val[e] = 0.0;
		pdata->dev_to_XYZ(pdata, XYZ, val);		/* Lookup white XYZ */

		sprintf(buf,"%f %f %f", 100.0  * XYZ[0], 100.0 * XYZ[1], 100.0 * XYZ[2]);
		pp->add_kword(pp, 0, "APPROX_WHITE_POINT", buf, NULL);
	}

	pp->add_field(pp, 0, "SAMPLE_ID", cs_t);
	pp->add_field(pp, 1, "INDEX", i_t);			/* Index no. 0..7 in second table */
	pp->add_field(pp, 2, "INDEX", i_t);			/* Index no. 0..7 in third table */

	/* Setup CGATS fields */
	{
		int j;
		char c_ilimit[20];
		char *bident = icx_inkmask2char(xmask, 0); 

		for (j = 0; j < di; j++) {
			int imask;
			char fname[100];

			imask = icx_index2ink(xmask, j);
			sprintf(fname,"%s_%s",nmask == ICX_W || nmask == ICX_K ? "GRAY" : bident,
								  icx_ink2char(imask));

			pp->add_field(pp, 0, fname, r_t);
			pp->add_field(pp, 1, fname, r_t);
			pp->add_field(pp, 2, fname, r_t);
		}

		pp->add_kword(pp, 0, "COLOR_REP", ident, NULL);

		if (uilimit >= 0.0) {
			sprintf(c_ilimit,"%5.1f",uilimit * 100.0);
			pp->add_kword(pp, 0, "TOTAL_INK_LIMIT", c_ilimit, NULL);
			if (ilimit != uilimit) {
				sprintf(c_ilimit,"%5.1f",ilimit * 100.0);
				pp->add_kword(pp, 0, "FINAL_TOTAL_INK_LIMIT", c_ilimit, NULL);
			}
		}
		if (utilimit >= 0.0 && utilimit != uilimit) {
			sprintf(c_ilimit,"%5.1f",utilimit * 100.0);
			pp->add_kword(pp, 0, "TEXT_SPACER_TOTAL_INK_LIMIT", c_ilimit, NULL);
			if (tilimit != utilimit) {
				sprintf(c_ilimit,"%5.1f",tilimit * 100.0);
				pp->add_kword(pp, 0, "FINAL_TEXT_SPACER_TOTAL_INK_LIMIT", c_ilimit, NULL);
			}
		}
		free(bident);
	}

	/* ilimit is assumed to be in a valid range from here on */
	if (ilimit < 0.0) {
		uilimit = ilimit = di;	/* default is no limit */
	}

	if (tilimit < 0.0) {
		utilimit = tilimit = di;	/* default is no limit */
	}

	/* Add expected XYZ values to aid previews, scan recognition & strip recognition */
	pp->add_field(pp, 0, "XYZ_X", r_t);
	pp->add_field(pp, 0, "XYZ_Y", r_t);
	pp->add_field(pp, 0, "XYZ_Z", r_t);
	pp->add_field(pp, 1, "XYZ_X", r_t);
	pp->add_field(pp, 1, "XYZ_Y", r_t);
	pp->add_field(pp, 1, "XYZ_Z", r_t);
	pp->add_field(pp, 2, "XYZ_X", r_t);
	pp->add_field(pp, 2, "XYZ_Y", r_t);
	pp->add_field(pp, 2, "XYZ_Z", r_t);

	/* Note if the expected values are expected to be accurate */
	if (pdata->is_specific(pdata))
		pp->add_kword(pp, 0, "ACCURATE_EXPECTED_VALUES", "true", NULL);

	if (xpow != 1.0) {
		sprintf(buf,"%f",xpow);
		pp->add_kword(pp, 0, "EXTRA_DEV_POW",buf, NULL);
	}

	if (demph > 1.0) {
		sprintf(buf,"%f",demph);
		pp->add_kword(pp, 0, "DARK_REGION_EMPHASIS",buf, NULL);
	}

	/* Only use optimsed full spread if <= 4 dimensions, else use ifarp */
	if (di > 4 
	 && userand == 0		/* Not other high D useful method */
	 && useqrand == 0
	 && usedsim == 0
	 && usepsim == 0)
		uselat = 1;

	/* Allocate space to record fixed steps */
	{
		fxlist_a = 4;
		if ((fxlist = (fxpos *)malloc(sizeof(fxpos) * fxlist_a)) == NULL)
		error ("Failed to malloc fxlist");
	}


	/* White color patches */
	if (esteps > 0)	{
		int j, e;

		sprintf(buf,"%d",esteps);
		pp->add_kword(pp, 0, "WHITE_COLOR_PATCHES",buf, NULL);
	
		for (j = 0; j < esteps; j++) {
			double val[MXTD], XYZ[3];
			cgats_set_elem ary[1 + MXTD + 3];
	
			if (nmask & ICX_ADDITIVE) {
				for (e = 0; e < di; e++) {
					val[e] = 1.0;			/* White is full colorant */
				}
			} else {
				for (e = 0; e < di; e++) {
					val[e] = 0.0;			/* White is no colorant */
				}
			}

			/* Apply general filter */
			if (filter && dofilt(pdata, filt, val))
				continue;

			sprintf(buf,"%d",id++);
			ary[0].c = buf;

			if (xmask == nmask) {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * val[e];
			} else {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * (1.0 - val[e]);
			}

			pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
			ary[1 + di + 0].d = 100.0 * XYZ[0];
			ary[1 + di + 1].d = 100.0 * XYZ[1];
			ary[1 + di + 2].d = 100.0 * XYZ[2];
	
			pp->add_setarr(pp, 0, ary);
	
			if (fxlist != NULL) {		/* Note in fixed list */
				if (fxno >= fxlist_a) {
					fxlist_a *= 2;
					if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
						error ("Failed to malloc fxlist");
				}
				for (e = 0; e < di; e++)
					fxlist[fxno].p[e] = val[e];
				fxlist[fxno].eloc = pp->t[0].nsets;
				fxno++;
			}
		}
	}

	/* Black color patches */
	if (Bsteps > 0)	{
		int j, k, e;

		for (j = k = 0; j < Bsteps; j++) {
			double val[MXTD], XYZ[3];
			cgats_set_elem ary[1 + MXTD + 3];
	
			if (nmask & ICX_ADDITIVE) {
				for (e = 0; e < di; e++) {
					val[e] = 0.0;			/* Black is no colorant */
				}
			} else {
				for (e = 0; e < di; e++) {
					val[e] = 1.0;			/* Black is full colorant */
				}
			}
	
			/* Apply general filter */
			if (filter && dofilt(pdata, filt, val))
				continue;

			/* Do a simple ink limit */
			pdata->limit_ink(pdata, val);

			sprintf(buf,"%d",id++);
			ary[0].c = buf;

			if (xmask == nmask) {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * val[e];
			} else {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * (1.0 - val[e]);
			}

			pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
			ary[1 + di + 0].d = 100.0 * XYZ[0];
			ary[1 + di + 1].d = 100.0 * XYZ[1];
			ary[1 + di + 2].d = 100.0 * XYZ[2];
	
			pp->add_setarr(pp, 0, ary);
	
			if (fxlist != NULL) {		/* Note in fixed list */
				if (fxno >= fxlist_a) {
					fxlist_a *= 2;
					if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
						error ("Failed to malloc fxlist");
				}
				for (e = 0; e < di; e++)
					fxlist[fxno].p[e] = val[e];
				fxlist[fxno].eloc = pp->t[0].nsets;
				fxno++;
			}
			k++;
		}
		sprintf(buf,"%d",k);
		pp->add_kword(pp, 0, "BLACK_COLOR_PATCHES",buf, NULL);
	
	}

	/* Primary (single channel) wedge steps */
	if (ssteps > 0)	{
		sprintf(buf,"%d",ssteps);
		pp->add_kword(pp, 0, "SINGLE_DIM_STEPS",buf, NULL);
		for (j = 0; j < di; j++) {
			for (i = 0; i < ssteps; i++) {
				int addp, e;
				double val[MXTD], XYZ[3];
				cgats_set_elem ary[1 + MXTD + 3];

				addp = 1;			/* Default add the point */

				for (e = 0; e < di; e++) {
					if (e == j)
						val[e] = (double)i/(ssteps-1);
					else
						val[e] = 0.0;
				}

				/* Extra power and dark emphasis */
				for (e = 0; e < di; e++)
					val[e] = icx_powlike(val[e], xpow * demph);

				/* See if it is already in the fixed list */
				if (!dontdedupe && fxlist != NULL) {
					int k;
					for (k = 0; k < fxno; k++) {
						for (e = 0; e < di; e++) {
							double tt;
							tt = fabs(fxlist[k].p[e] - val[e]);
							if (tt > MATCH_TOLL)
								break;			/* Not identical */
						}
						if (e >= di)
							break;				/* Was identical */
					}
					if (k < fxno)				/* Found an identical patch */
						addp = 0;				/* Don't add the point */
				}

				/* Apply general filter */
				if (filter && dofilt(pdata, filt, val))
					addp = 0;

				if (addp) {
		
					sprintf(buf,"%d",id++);
					ary[0].c = buf;

					if (xmask == nmask) {
						for (e = 0; e < di; e++)
							ary[1 + e].d = 100.0 * val[e];
					} else {
						for (e = 0; e < di; e++)
							ary[1 + e].d = 100.0 * (1.0 - val[e]);
					}

					pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
					ary[1 + di + 0].d = 100.0 * XYZ[0];
					ary[1 + di + 1].d = 100.0 * XYZ[1];
					ary[1 + di + 2].d = 100.0 * XYZ[2];
	
					pp->add_setarr(pp, 0, ary);
		
					if (fxlist != NULL) {		/* Note in fixed list */
						if (fxno >= fxlist_a) {
							fxlist_a *= 2;
							if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
								error ("Failed to malloc fxlist");
						}
						for (e = 0; e < di; e++)
							fxlist[fxno].p[e] = val[e];
						fxlist[fxno].eloc = -1;
						fxno++;
					}
				}
			}
		}
	}

	/* Composite gray wedge steps */
	if (gsteps > 0) {
		int cix[3];		/* Composite indexes */ 

		sprintf(buf,"%d",gsteps);
		pp->add_kword(pp, 0, "COMP_GREY_STEPS",buf, NULL);

		if (nmask & ICX_ADDITIVE) {	/* Look for the RGB */
			cix[0] = icx_ink2index(nmask, ICX_RED);
			cix[1] = icx_ink2index(nmask, ICX_GREEN);
			cix[2] = icx_ink2index(nmask, ICX_BLUE);

		} else {					/* Look for the CMY */
			cix[0] = icx_ink2index(nmask, ICX_CYAN);
			cix[1] = icx_ink2index(nmask, ICX_MAGENTA);
			cix[2] = icx_ink2index(nmask, ICX_YELLOW);
		}
		if (cix[0] < 0 || cix[1] < 0 || cix[2] < 0)
			error("Composite grey wedges aren't appropriate for %s device\n",ident);

		for (i = 0; i < gsteps; i++) {
			int addp, e;
			double sum, val[MXTD], XYZ[3];
			cgats_set_elem ary[1 + MXTD + 3];

			addp = 1;			/* Default add the point */

			for (e = 0; e < di; e++) {
				if (e == cix[0] || e == cix[1] || e == cix[2])
					val[e] = (double)i/(gsteps-1);
				else
					val[e] = 0.0;
			}

			/* Extra power and dark emphasis */
			for (e = 0; e < di; e++)
				val[e] = icx_powlike(val[e], xpow * demph);

			/* Apply general filter */
			if (filter && dofilt(pdata, filt, val))
				addp = 0;

			/* Check if over ink limit */
			if (pdata->limit_ink(pdata, val))
				addp = 0;

			/* See if it is already in the fixed list */
			if (!dontdedupe && fxlist != NULL) {
				int k;
				for (k = 0; k < fxno; k++) {
					for (e = 0; e < di; e++) {
						double tt;
						tt = fabs(fxlist[k].p[e] - val[e]);
						if (tt > MATCH_TOLL)
							break;			/* Not identical */
					}
					if (e >= di)
						break;				/* Was identical */
				}
				if (k < fxno)				/* Found an identical patch */
					addp = 0;				/* Don't add the point */
			}

			if (addp) {
	
				sprintf(buf,"%d",id++);
				ary[0].c = buf;

				if (xmask == nmask) {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * val[e];
				} else {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * (1.0 - val[e]);
				}

				pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
				ary[1 + di + 0].d = 100.0 * XYZ[0];
				ary[1 + di + 1].d = 100.0 * XYZ[1];
				ary[1 + di + 2].d = 100.0 * XYZ[2];

				pp->add_setarr(pp, 0, ary);
	
				if (fxlist != NULL) {		/* Note in fixed list */
					if (fxno >= fxlist_a) {
						fxlist_a *= 2;
						if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
							error ("Failed to malloc fxlist");
					}
					for (e = 0; e < di; e++)
						fxlist[fxno].p[e] = val[e];
					fxlist[fxno].eloc = -1;
					fxno++;
				}
			}
		}
	}

	/* Neutral wedge steps */
	if (nsteps > 0) {
		double lab[3];

		sprintf(buf,"%d",nsteps);
		pp->add_kword(pp, 0, "NEUTRAL_STEPS",buf, NULL);

		lab[1] = lab[2] = 0.0;
		for (i = 0; i < nsteps; i++) {
			int addp, e;
			double sum, val[MXTD], XYZ[3];
			cgats_set_elem ary[1 + MXTD + 3];

			addp = 1;			/* Default add the point */

			lab[0] = 100.0 * (double)i/(nsteps-1);

			pdata->rLab_to_dev(pdata, val, lab);

			/* Apply general filter */
			if (filter && dofilt(pdata, filt, val))
				addp = 0;

			/* Check if over ink limit */
			if (pdata->limit_ink(pdata, val))
				addp = 0;

			/* See if it is already in the fixed list */
			if (!dontdedupe && fxlist != NULL) {
				int k;
				for (k = 0; k < fxno; k++) {
					for (e = 0; e < di; e++) {
						double tt;
						tt = fabs(fxlist[k].p[e] - val[e]);
						if (tt > MATCH_TOLL)
							break;			/* Not identical */
					}
					if (e >= di)
						break;				/* Was identical */
				}
				if (k < fxno)				/* Found an identical patch */
					addp = 0;				/* Don't add the point */
			}

			if (addp) {
	
				sprintf(buf,"%d",id++);
				ary[0].c = buf;

				if (xmask == nmask) {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * val[e];
				} else {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * (1.0 - val[e]);
				}

				pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
				ary[1 + di + 0].d = 100.0 * XYZ[0];
				ary[1 + di + 1].d = 100.0 * XYZ[1];
				ary[1 + di + 2].d = 100.0 * XYZ[2];

				pp->add_setarr(pp, 0, ary);
	
				if (fxlist != NULL) {		/* Note in fixed list */
					if (fxno >= fxlist_a) {
						fxlist_a *= 2;
						if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
							error ("Failed to malloc fxlist");
					}
					for (e = 0; e < di; e++)
						fxlist[fxno].p[e] = val[e];
					fxlist[fxno].eloc = -1;
					fxno++;
				}
			}
		}
	}

	/* Regular Gridded Multi dimension steps */
	if (msteps > 0) {
		int gc[MXTD];			/* Grid coordinate */

		sprintf(buf,"%d",msteps);
		pp->add_kword(pp, 0, "MULTI_DIM_STEPS",buf, NULL);

		for (j = 0; j < di; j++)
			gc[j] = 0;			/* init coords */
			
		for (;;) {	/* For all grid points */
			double sum, val[MXTD], XYZ[3];
			int addp, e;

			/* If just surface points, reject points not on (2D) surface */
			if (msurf) {
				for (k = e = 0; e < di; e++) {
					if (gc[e] != 0 && gc[e] != (msteps-1))
						k++;
				}
				if (k > 2)
					goto next_point;
			}

			addp = 1;			/* Default add the point */

			for (e = 0; e < di; e++)
				val[e] = (double)gc[e]/(msteps-1);

			/* Extra power and dark emphasis */
			for (e = 0; e < di; e++)
				val[e] = icx_powlike(val[e], xpow * demph);

			/* Apply general filter */
			if (filter && dofilt(pdata, filt, val))
				addp = 0;

			/* Check if over ink limit */
			if (pdata->limit_ink(pdata, val))
				addp = 0;

			/* See if it is already in the fixed list */
			if (addp && !dontdedupe && fxlist != NULL) { 
				int k;
				for (k = 0; k < fxno; k++) {
					for (e = 0; e < di; e++) {
						double tt;
						tt = fabs(fxlist[k].p[e] - val[e]);
						if (tt > MATCH_TOLL)
							break;			/* Not identical */
					}
					if (e >= di)
						break;				/* Was identical */
				}
				if (k < fxno)				/* Found an identical patch */
					addp = 0;				/* Don't add the point */
			}

			/* Add patch to list if OK */
			if (addp) {
				cgats_set_elem ary[1 + MXTD + 3];

				sprintf(buf,"%d",id++);
				ary[0].c = buf;

				if (xmask == nmask) {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * val[e];
				} else {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * (1.0 - val[e]);
				}

				pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
				ary[1 + di + 0].d = 100.0 * XYZ[0];
				ary[1 + di + 1].d = 100.0 * XYZ[1];
				ary[1 + di + 2].d = 100.0 * XYZ[2];

				pp->add_setarr(pp, 0, ary);

				if (fxlist != NULL) {		/* Note in fixed list */
					if (fxno >= fxlist_a) {
						fxlist_a *= 2;
						if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
							error ("Failed to malloc fxlist");
					}
					for (e = 0; e < di; e++)
						fxlist[fxno].p[e] = val[e];
					fxlist[fxno].eloc = -1;
					fxno++;
				}
			}

			/* Increment grid index and position */
		  next_point:;
			for (j = 0; j < di; j++) {
				gc[j]++;
				if (gc[j] < msteps)
					break;	/* No carry */
				gc[j] = 0;
			}
			if (j >= di)
				break;		/* Done grid */
		}

#ifdef ADDRECCLIPPOINTS
		/* Add extra points that intersect */
		/* grid, and lie on ink limit plane */
		/* !!!!!!!!!! this doesn't cope with xpow or ilimit != uilimit !!!!!!!!!!! */
		if (uilimit > 0.0 && uilimit < (di * 100.0)) {
			double val[MXTD], tv;
			double XYZ[3];
			for (k = 0; k < di; k++) {	/* dimension not on grid */
				for (j = 0; j < di; j++)
					gc[j] = 0;			/* init coords */
					
				for (;;) {	/* Until done */
					for (tv = 0.0, j = 0; j < di; j++) {
						if (j != k)
							tv += val[j] = (double)gc[j]/(msteps-1);
					}
					if (tv <= uilimit && (tv + 1.0) >= uilimit) {	/* Will intersect */
						double fr;
						val[k] = uilimit - tv; 	/* Point of intersection */
						fr = fmod((val[k] * msteps), 1.0);
						if (fr > 0.05 && fr < 0.95) {		/* Not within 5% of a grid point */ 
							int addp, e;
							cgats_set_elem ary[1 + MXTD + 3];
			
							addp = 1;			/* Default add the point */

							/* See if it is already in the fixed list */
							if (!dontdedupe && fxlist != NULL) {
								int k;
								for (k = 0; k < fxno; k++) {
									for (e = 0; e < di; e++) {
										double tt;
										tt = fabs(fxlist[k].p[e] - val[e]);
										if (tt > MATCH_TOLL)
											break;			/* Not identical */
									}
									if (e >= di)
										break;				/* Was identical */
								}
								if (k < fxno) {				/* Found an identical patch */
									addp = 0;				/* Don't add the point */
								}
							}

							/* Apply general filter */
							if (filter && dofilt(pdata, filt, val)) {
								addp = 0;
							}

							if (addp) {
								sprintf(buf,"%d",id++);
								ary[0].c = buf;
								if (xmask == nmask) {
									for (e = 0; e < di; e++)
										ary[1 + e].d = 100.0 * val[e];;
								} else {
									for (e = 0; e < di; e++)
										ary[1 + e].d = 100.0 * (1.0 - val[e]);
								}
								pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
								ary[1 + di + 0].d = 100.0 * XYZ[0];
								ary[1 + di + 1].d = 100.0 * XYZ[1];
								ary[1 + di + 2].d = 100.0 * XYZ[2];

								pp->add_setarr(pp, 0, ary);
	
								if (fxlist != NULL) {		/* Note in fixed list */
									if (fxno >= fxlist_a) {
										fxlist_a *= 2;
										if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
											error ("Failed to malloc fxlist");
									}
									for (e = 0; e < di; e++)
										fxlist[fxno].p[e] = val[e];
									fxlist[fxno].eloc = -1;
									fxno++;
								}
							}
						}
					}

					/* Increment grid index and position */
					for (j = 0; j < di; j++) {
						gc[j]++;
						if (j != k && gc[j] < msteps)
							break;	/* No carry */
						gc[j] = 0;
					}
					if (j >= di)
						break;		/* ALL done */
				}
			}
		}
#endif /* ADDRECCLIPPOINTS */
	}


	/* Regular body centered cubic gridded Multi dimension steps */
	if (bsteps > 0) {
		int gc[MXTD];			/* Grid coordinate */
		int pass = 0;			/* 0 = outer grid, 1 = inner grid */

		sprintf(buf,"%d",bsteps);
		pp->add_kword(pp, 0, "MULTI_DIM_BCC_STEPS",buf, NULL);

		for (pass = 0; pass < 2; pass++) {

			for (j = 0; j < di; j++)
				gc[j] = 0;			/* init coords */
				
			for (;;) {	/* For all grid points */
				double sum, val[MXTD], XYZ[3];
				int addp, e;

				addp = 1;			/* Default add the point */

				for (e = 0; e < di; e++)
					val[e] = (double)(pass * 0.5 + gc[e])/(bsteps-1);

				/* Extra power and dark emphasis */
				for (e = 0; e < di; e++)
					val[e] = icx_powlike(val[e], xpow * demph);

				/* Apply general filter */
				if (filter && dofilt(pdata, filt, val))
					addp = 0;

				/* Check if over ink limit */
				if (pdata->limit_ink(pdata, val))
					addp = 0;

				/* See if it is already in the fixed list */
				if (addp && !dontdedupe && fxlist != NULL) { 
					int k;
					for (k = 0; k < fxno; k++) {
						for (e = 0; e < di; e++) {
							double tt;
							tt = fabs(fxlist[k].p[e] - val[e]);
							if (tt > MATCH_TOLL)
								break;			/* Not identical */
						}
						if (e >= di)
							break;				/* Was identical */
					}
					if (k < fxno)				/* Found an identical patch */
						addp = 0;				/* Don't add the point */
				}

				/* Add patch to list if OK */
				if (addp) {
					cgats_set_elem ary[1 + MXTD + 3];

					sprintf(buf,"%d",id++);
					ary[0].c = buf;
					if (xmask == nmask) {
						for (e = 0; e < di; e++)
							ary[1 + e].d = 100.0 * val[e];
					} else {
						for (e = 0; e < di; e++)
							ary[1 + e].d = 100.0 * (1.0 - val[e]);
					}

					pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
					ary[1 + di + 0].d = 100.0 * XYZ[0];
					ary[1 + di + 1].d = 100.0 * XYZ[1];
					ary[1 + di + 2].d = 100.0 * XYZ[2];

					pp->add_setarr(pp, 0, ary);

					if (fxlist != NULL) {		/* Note in fixed list */
						if (fxno >= fxlist_a) {
							fxlist_a *= 2;
							if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
								error ("Failed to malloc fxlist");
						}
						for (e = 0; e < di; e++)
							fxlist[fxno].p[e] = val[e];
						fxlist[fxno].eloc = -1;
						fxno++;
					}
				}

				/* Increment grid index and position */
				for (j = 0; j < di; j++) {
					gc[j]++;
					if ((pass == 0 && gc[j] < bsteps)
					 || (pass == 1 && gc[j] < (bsteps-1)))
						break;	/* No carry */
					gc[j] = 0;
				}
				if (j >= di)
					break;		/* Done grid */
			}
		}
	}

#ifdef COMMPLUS     /* Commercial+ */
	/* N-channel structured chart */
#ifdef NEVER
	/* Code to generate clth[17][17] data: */
	if (Hsize > 0) {
		unsigned int n, i, j;
		int ltcount[17];

		if (di > 16)
			error("N-channel must be 16 or less than channels");

		/* Create table of dimension vs. number of combs with */
		/* less than or equal to x inks. */
		printf("/*");
		for (j = 0; j <= 16; j++)
			printf(" %d",j);
		printf(" */\n");
		for (n = 1; n <= 16; n++) {
			int n2 = 1 << n;

			for (j = 0; j <= n; j++)
				ltcount[j] = 0;

			for (i = 0; i < n2; i++) {
				int bc;

				bc = count_set_bits(i);

				for (j = 0; j <= n; j++) {
					if (bc <= j)
						ltcount[j]++;
				}
			}
			printf("/* %d */	{ ",n);
			for (j = 0; j <= n; j++)
				printf("%s%d",j == 0 ? "" : ", ", ltcount[j]);
			printf(" },\n");
		}
	}
#endif /* NEVER */
	if (Hsize > 0) {
		/* Count of combinations out of 2^di that have less than m bits set. */
		/* clth[di][m] */
		int clth[17][17] = {
				   /* 0   1    2    3     4     5     6    7      8      9     10 11 12 13 14 15 16 */
					{ 0 },
			/* 1 */	{ 1,  2 },
			/* 2 */	{ 1,  3,   4 },
			/* 3 */	{ 1,  4,   7,   8 },
			/* 4 */	{ 1,  5,  11,  15,   16 },
			/* 5 */	{ 1,  6,  16,  26,   31,   32 },
			/* 6 */	{ 1,  7,  22,  42,   57,   63,   64 },
			/* 7 */	{ 1,  8,  29,  64,   99,  120,  127, 128 },
			/* 8 */	{ 1,  9,  37,  93,  163,  219,  247, 255,   256 },
			/* 9 */	{ 1, 10,  46, 130,  256,  382,  466, 502,   511,   512 },
			/* 10 */{ 1, 11,  56, 176,  386,  638,  848, 968,  1013,  1023,  1024 },
			/* 11 */{ 1, 12,  67, 232,  562, 1024, 1486, 1816, 1981,  2036,  2047,  2048 },
			/* 12 */{ 1, 13,  79, 299,  794, 1586, 2510, 3302, 3797,  4017,  4083,  4095, 4096 },
			/* 13 */{ 1, 14,  92, 378, 1093, 2380, 4096, 5812, 7099,  7814,  8100,  8178, 8191,
			                                                                              8192 },
			/* 14 */{ 1, 15, 106, 470, 1471, 3473, 6476, 9908, 12911, 14913, 15914, 16278, 16369,
			                                                                        16383, 16384 },
			/* 15 */{ 1, 16, 121, 576, 1941, 4944, 9949, 16384, 22819, 27824, 30827, 32192, 32647,
			                                                                 32752, 32767, 32768 },
			/* 16 */{ 1, 17, 137, 697, 2517, 6885, 14893, 26333, 39203, 50643, 58651, 63019, 64839,
			                                                          65399, 65519, 65535, 65536 },
		};
		int s1, s2, s3;			/* Resolution of single ink, double ink, 3 ink combo's */
		int chl1, chl2, chl3;	/* Channel limit of corner, edge and face combinations */
		int n;
		int ns1, ns2, ns3;		/* Number of patches for 1 ink, 2 ink, 3 ink wedges */
		int nc, ne, nf;			/* Number of corners, edges, faces */

		for (n = 3; n <= 16; n++) {

			if (n >= 6 && Hsize <= 1) {
				s1 = 31;
				s2 = 6;
				s3 = 3;
				chl1 = 4;
				chl2 = 4;
				chl3 = 4;
			} else if (n >= 8 && Hsize <= 2) {
				s1 = 31;
				s2 = 7;
				s3 = 4;
				chl1 = 4;
				chl2 = 4;
				chl3 = 4;
			} else {		/* Small di or Hsize == 3 */
				s1 = 31;
				s2 = 9;
				s3 = 5;
				chl1 = 4;
				chl2 = 4;
				chl3 = 4;
			}
			if (n > 8) {
				chl2 = 3;
				chl3 = 3;
			}
			if (n > 10) {
				chl2 = 2;
				chl3 = 0;
			}

			ns1 = n * s1;						/* Number of regular 1 ink (wedges) */ 
			ns2 = n * (n-1)/2 * s2; 			/* Number of regular 2 ink */
			ns3 = (n * (n-1) * (n-2))/6 * s3;	/* Number of regular 3 ink */

			nc = clth[n][chl1];					/* Number of corners */
			ne = n * clth[n-1][chl2 <= n-1 ? chl2 : n-1];			/* Number of edges */
			if (chl3 > 0)
				nf = n * (n-1)/2 * clth[n-2][chl3 < n-2 ? chl3 : n-2];	/* Number of faces */
			else
				nf = 0;

			printf("n = %d, size = %d:\n",n, Hsize);
			printf("ns1 = %d, ns2 = %d, ns3 = %d\n",ns1,ns2,ns3);
			printf("nc  = %d, ne  = %d,  nf = %d\n",nc,ne,nf);
			printf("Total patches = %d\n",ns1 + ns2 + ns3 + nc + ne + nf); 
		
			printf("\n");
		
		}
	}
#endif

	if (fsteps > fxno) { /* Top up with full spread (perceptually even) and other patch types */

		/* Generate device random numbers. Don't check for duplicates */
		if (userand == 1 || useqrand == 1) {
			int i, j;
			sobol *sl = NULL;

			if (useqrand) {
				if ((sl = new_sobol(di)) == NULL)
					error("Creating sobol sequence generator failed");
			}

			/* Create more points up to fsteps */
			if (verb)
				printf("\n");
			for (j = 0, i = fxno; i < fsteps;) {
				int e;
				double sum;
				double val[MXTD], XYZ[3];
				cgats_set_elem ary[1 + MXTD + 3];

				if (sl != NULL) {
					if (sl->next(sl, val))
						error("Run out of sobol random numbers!");
				} else {	/* else uniform random distribution */
					for (e = 0; e < di; e++)
						val[e] = d_rand(0.0, 1.0);
				}

				/* Extra power and dark emphasis */
				for (e = 0; e < di; e++)
					val[e] = icx_powlike(val[e], xpow * demph);

				/* Apply general filter */
				if (filter && dofilt(pdata, filt, val))
					continue;

				/* Check if over ink limit */
				if (pdata->limit_ink(pdata, val))
					continue;

				sprintf(buf,"%d",id++);
				ary[0].c = buf;
				if (xmask == nmask) {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * val[e];
				} else {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * (1.0 - val[e]);
				}

				pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
				ary[1 + di + 0].d = 100.0 * XYZ[0];
				ary[1 + di + 1].d = 100.0 * XYZ[1];
				ary[1 + di + 2].d = 100.0 * XYZ[2];
	
				pp->add_setarr(pp, 0, ary);

				if (fxlist != NULL) {		/* Note in fixed list to allow stats later */
					if (fxno >= fxlist_a) {
						fxlist_a *= 2;
						if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
							error ("Failed to malloc fxlist");
					}
					for (e = 0; e < di; e++)
						fxlist[fxno].p[e] = val[e];
					fxlist[fxno].eloc = -1;
					fxno++;
				}

				if (verb) {
					printf("%cAdded %d/%d",cr_char,i+1,fxno); fflush(stdout);
				}
				i++, j++;
			}
			if (verb)
				printf("\n");

			sprintf(buf,"%d",j);
			if (sl != NULL)
				pp->add_kword(pp, 0, "SPACEFILLING_RANDOM_PATCHES", buf, NULL);
			else
				pp->add_kword(pp, 0, "RANDOM_DEVICE_PATCHES", buf, NULL);

			if (sl != NULL)
				sl->del(sl);

		} else {
//			ppoint *s = NULL;
			ofps *s = NULL;
			ifarp *t = NULL;
			simdlat *dx = NULL;
			simplat *px = NULL;
			prand *rx = NULL;

			/* (Note that the ink limit for these algorithms won't take into account the xpow */
			/* and ilimit != uilimit, and that we're not applying the filter until after */
			/* generation, so the number of patches won't reach the target. This could be */
			/* fixed fairly easily for some of these (new_prand).  */
			if (uselat)	 {
				/* A "greedy"/incremental far point approach. */
				t = new_ifarp(verb, di, uilimit, fsteps, fxlist, fxno,
		                (void(*)(void *, double *, double *))pdata->dev_to_perc,(void *)pdata);
				sprintf(buf,"%d",fsteps - fxno);
				pp->add_kword(pp, 0, "IFP_PATCHES", buf, NULL);
			} else if (usedsim) {
				/* Device space simplex latice test points */
				dx = new_simdlat(di, uilimit, fsteps, fxlist, fxno, SIMDLAT_TYPE, simangle,
			                (void(*)(void *, double *, double *))pdata->dev_to_perc, (void *)pdata);
				sprintf(buf,"%d",fsteps - fxno);
				pp->add_kword(pp, 0, "SIMPLEX_DEVICE_PATCHES", buf, NULL);
			} else if (usepsim) {
				/* Perceptual space simplex latice test points */
				px = new_simplat(di, uilimit, fsteps, fxlist, fxno, simangle,
			                (void(*)(void *, double *, double *))pdata->dev_to_perc, (void *)pdata);
				sprintf(buf,"%d",fsteps - fxno);
				pp->add_kword(pp, 0, "SIMPLEX_PERCEPTUAL_PATCHES", buf, NULL);
			} else if (userand == 2 || useqrand == 2) {
				/* Perceptual random test points */
				rx = new_prand(di, uilimit, fsteps, fxlist, fxno, useqrand == 2 ? 1 : 0,
			                (void(*)(void *, double *, double *))pdata->dev_to_perc, (void *)pdata);
				sprintf(buf,"%d",fsteps - fxno);
				pp->add_kword(pp, 0, "RANDOM_PERCEPTUAL_PATCHES", buf, NULL);

			} else {		/* Default full spread algorithm */
				/* Optimised Farthest Point Sampling */
				s = new_ofps(verb, di, uilimit, fsteps, good,
				            dadapt, 1.0 - perc_wght, perc_wght, curv_wght, fxlist, fxno,
			                (void(*)(void *, double *, double *))pdata->dev_to_perc, (void *)pdata);
				sprintf(buf,"%d",fsteps - fxno);
				pp->add_kword(pp, 0, "OFPS_PATCHES", buf, NULL);
			}

	
			for (;;) {
				int e;
				double XYZ[3], val[MXTD];
				cgats_set_elem ary[1 + MXTD + 3];
				if (( s ? s->read(s, val, NULL) :
				      t ? t->read(t, val, NULL) :
				     dx ? dx->read(dx, val, NULL) :
				     rx ? rx->read(rx, val, NULL) :
				          px->read(px, val, NULL)))
					break;
	
				/* Filter out silly values from ppoint */
				for (e = 0; e < di; e++) {
					if (val[e] < 0.001)
						val[e] = 0.0;
					else if (val[e] > 0.999)
						val[e] = 1.0;
				}
			
				/* Apply general filter */
				if (filter && dofilt(pdata, filt, val))
					continue;

				/* Do a simple ink limit */
				pdata->limit_ink(pdata, val);

				sprintf(buf,"%d",id++);
				ary[0].c = buf;
				if (xmask == nmask) {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * val[e];
				} else {
					for (e = 0; e < di; e++)
						ary[1 + e].d = 100.0 * (1.0 - val[e]);
				}

				pdata->dev_to_XYZ(pdata, XYZ, val);		/* Add expected XYZ */
				ary[1 + di + 0].d = 100.0 * XYZ[0];
				ary[1 + di + 1].d = 100.0 * XYZ[1];
				ary[1 + di + 2].d = 100.0 * XYZ[2];
	
				pp->add_setarr(pp, 0, ary);

				if (fxlist != NULL) {		/* Note in fixed list to allow stats later */
					if (fxno >= fxlist_a) {
						fxlist_a *= 2;
						if ((fxlist = (fxpos *)realloc(fxlist, sizeof(fxpos) * fxlist_a)) == NULL)
							error ("Failed to malloc fxlist");
					}
					for (e = 0; e < di; e++)
						fxlist[fxno].p[e] = val[e];
					fxlist[fxno].eloc = -1;
					fxno++;
				}
			}
			(s ? s->del(s) : t ? t->del(t) : dx ? dx->del(dx) : rx ? rx->del(rx) : px->del(px));
		}
	}

	/* Even the location of marked patches into sequence */
	if (fxno < pp->t[0].nsets
	) {
		int ii, p1, p2, t1;

		/* For each patch to be dispersed */
		for (ii = 0; ii < fxno; ii++) {
			if (fxlist[ii].eloc >= 0) {
				p1 = fxlist[ii].eloc;

				for (k = 0; k < 10; k++) {		/* Retry 10 times */

					/* Pick a random patch to exchange it with */
					p2 = i_rand(0, pp->t[0].nsets-1);
	
					/* Check it isn't one of our patches to be dispersed */
					for (i = 0; i < fxno; i++) {
						if (fxlist[i].eloc == p2)
							break;
					}
					if (i < fxno)
						continue;		/* Try another patch to exchange with */

					/* Swap */
					for (j = 1; j < (1 + di + 3); j++) {
						double tt = *((double *)pp->t[0].fdata[p1][j]);
						*((double *)pp->t[0].fdata[p1][j]) = *((double *)pp->t[0].fdata[p2][j]);
						*((double *)pp->t[0].fdata[p2][j]) = tt;
					}
					fxlist[ii].eloc = p2;

					break;
				}
			}
		}
	}

	/* Go though all the points and make sure that they are under the ink limit (if any) */
	/* This will clip the final raw device values to the ilimit if there is a .cal file. */
	{
		int npat = pp->t[0].nsets;
		double ivals[MXTD], vals[MXTD];
		int i, j;

		for (i = 0; i < npat; i++) {
			for (j = 0; j < di; j++)
				ivals[j] = vals[j] = 0.01 * *((double *)pp->t[0].fdata[i][1+j]);
			if (pdata->limit_ink(pdata, vals)) {
				double XYZ[3];
				for (j = 0; j < di; j++)
					*((double *)pp->t[0].fdata[i][1+j]) = 100.0 * vals[j];

//printf("~1 clipped point %d from %s\n",i,debPdv(di, ivals));
//printf("~1                     to %s\n",debPdv(di, vals));

				pdata->dev_to_XYZ(pdata, XYZ, vals);		/* Recompute expected XYZ */
				*((double *)pp->t[0].fdata[i][1 + di + 0]) = XYZ[0];
				*((double *)pp->t[0].fdata[i][1 + di + 1]) = XYZ[1];
				*((double *)pp->t[0].fdata[i][1 + di + 2]) = XYZ[2];
			}
		}
	}

	/* If this seems to be for a CRT, optimise the patch order to minimise the */
	/* response time delays */
	if (nmask == ICX_RGB && pp->t[0].nsets > 1 && dontreorder == 0) {
		int npat = pp->t[0].nsets;
		char *nm;						/* Don't move array */
		double udelay, *delays, adelay;
		double temp, trate;	/* Annealing temperature & rate */
		double tstart, tend;/* Annealing chedule range */

		if ((nm = (char *)malloc(sizeof(char) * npat)) == NULL)
			error ("Failed to malloc nm array");
		if ((delays = (double *)malloc(sizeof(double) * npat)) == NULL)
			error ("Failed to malloc delay array");

		/* Set nm[] to mark patches that shouldn't be moved */
		for (i = 0; i < npat; i++)
			nm[i] = 0;
		for (i = 0; i < fxno; i++) {
			if (fxlist[i].eloc >= 0)
				nm[fxlist[i].eloc] = 1;
		}

#ifdef NEVER
		/* Randomly shuffle patches */
		{
			int p1, p2;

			for (p1 = 0; p1 < npat; p1++) {
	
				if (nm[p1])
					continue;

				p2 = i_rand(0, npat-1);
				if (nm[p2])
					continue;
				for (j = 1; j < (1 + di + 3); j++) {
					double tt = *((double *)pp->t[0].fdata[p1][j]);
					*((double *)pp->t[0].fdata[p1][j]) = *((double *)pp->t[0].fdata[p2][j]);
					*((double *)pp->t[0].fdata[p2][j]) = tt;
				}
			}
		}
#endif
#ifdef NEVER
		/* Simple sort by brightness */
		{
			int p1, p2;
			double rgb1, rgb2;

			for (p1 = 0; p1 < (npat-1); p1++) {
	
				if (nm[p1])
					continue;

				rgb1 = pow(*((double *)pp->t[0].fdata[p1][1 + 0]), 2.2)
				     + pow(*((double *)pp->t[0].fdata[p1][1 + 1]), 2.2)
				     + pow(*((double *)pp->t[0].fdata[p1][1 + 2]), 2.2);
	
				for (p2 = p1 + 1; p2 < npat; p2++) {

					if (nm[p2])
						continue;

					rgb2 = pow(*((double *)pp->t[0].fdata[p2][1 + 0]), 2.2)
					     + pow(*((double *)pp->t[0].fdata[p2][1 + 1]), 2.2)
					     + pow(*((double *)pp->t[0].fdata[p2][1 + 2]), 2.2);
		
					if (rgb2 < rgb1) {
						for (j = 1; j < (1 + di + 3); j++) {
							double tt = *((double *)pp->t[0].fdata[p1][j]);
							*((double *)pp->t[0].fdata[p1][j]) = *((double *)pp->t[0].fdata[p2][j]);
							*((double *)pp->t[0].fdata[p2][j]) = tt;
						}
						rgb1 = rgb2;
					}
				}
			}
		}
#endif
		/* Compute the current overall update delay */
		udelay = 0.0;
		for (i = 1; i < npat; i++) {
			double xdelay;

			xdelay = disprespt(pp, i-1, i);

			delays[i] = xdelay;
//printf("~1 delay[%d] = %f\n",i,xdelay);
			udelay += xdelay;
		}

		if (verb)
			printf("Extra display response delay = %f sec., optimizing....\n",udelay);

		{
			int nchunks, chsize;
			int chstart, chend;

			if (verb)
				printf("%c%2d%%",cr_char,0); fflush(stdout);

			/* We'll do this in chunks of 500 to make it linear time overall, */
			/* at the cost of the best possible optimisation. */
			nchunks = (int)ceil(npat/500.0); 
			chsize = (int)ceil(npat/nchunks);
			for (chstart = 0; chstart < npat; chstart += chsize) {
				int p1, p2, bp2;
				double p1d, p2d, p1d1, p2d1;
				double p1nd, p2nd, p1nd1, p2nd1;
				double tdelay, bdelay, de;
				int noswapped;

				chend = chstart + chsize+2;
				if (chend > npat)
					chend = npat;
				noswapped = chend - chstart;
//printf("~1 chstart %d, chend %d, size %d\n",chstart,chend, chend - chstart);

				/* While we are still improving, and the improvement was significant */
				for (;noswapped > 2;) {
					noswapped = 0;

					for (p1 = chstart + 1; p1 < chend; p1++) {
						if (nm[p1])
							continue;

						p1d = delays[p1];

						/* Locate the patch ahead of us that is best to swap with */
						bp2 = -1;
						bdelay = udelay;
						for (p2 = p1 + 2; p2 < chend; p2++) {

							if (nm[p2])
								continue;

							/* Compute effect of a swap on the total delay */
							p2d = delays[p2];
							p1nd = disprespt(pp, p2-1, p1);
							p2nd = disprespt(pp, p1-1, p2);
							p1d1 = p1nd1 = 0.0;
							if ((p1+1) < chend) {
								p1d1 = delays[p1+1];
								p1nd1 = disprespt(pp, p2, p1+1);
							}
							p2d1 = p2nd1 = 0.0;
							if ((p2+1) < chend) {
								p2d1 = delays[p2+1];
								p2nd1 = disprespt(pp, p1, p2+1);
							}
			
							tdelay = udelay - p1d - p2d - p1d1 - p2d1 + p1nd + p2nd + p1nd1 + p2nd1;

							if (tdelay < bdelay)		/* Improve it */
//							if (tdelay > bdelay)		/* Make it worse */
							{
								bp2 = p2;
								bdelay = tdelay;
							}
						}
						if (bp2 < 0) {
							continue;
						} 

						/* Swap the patches */
						noswapped++;

						p2 = bp2;

						p2d = delays[p2];
						p1nd = disprespt(pp, p2-1, p1);
						p2nd = disprespt(pp, p1-1, p2);
						p1d1 = p1nd1 = 0.0;
						if ((p1+1) < chend) {
							p1d1 = delays[p1+1];
							p1nd1 = disprespt(pp, p2, p1+1);
						}
						p2d1 = p2nd1 = 0.0;
						if ((p2+1) < chend) {
							p2d1 = delays[p2+1];
							p2nd1 = disprespt(pp, p1, p2+1);
						}

						tdelay = udelay - p1d - p2d - p1d1 - p2d1 + p1nd + p2nd + p1nd1 + p2nd1;

						/* Swap the values */
						udelay = tdelay;
						delays[p2] = p1nd;
						delays[p1] = p2nd;
						if (p1 < (chend-1))
							delays[p1+1] = p1nd1;
						if (p2 < (chend-1))
							delays[p2+1] = p2nd1;

						for (j = 1; j < (1 + di + 3); j++) {
							double tt = *((double *)pp->t[0].fdata[p1][j]);
							*((double *)pp->t[0].fdata[p1][j]) = *((double *)pp->t[0].fdata[p2][j]);
							*((double *)pp->t[0].fdata[p2][j]) = tt;
						}
//printf("~1 swaping %d and %d, udelay %f\n",p1,p2,udelay);
					}
//printf("~1 udelay %f\n",udelay);
					if (verb) {
						printf("%c%2d%%",cr_char,(int)(100.0 * (chend-1 - noswapped)/(npat-1.0)));
						fflush(stdout);
					}
				}
			}
			if (verb)
				printf("%c%2d%%",cr_char,100); fflush(stdout);
		}
		if (verb)
			printf("\nOptimised display response delay = %f sec.\n",udelay);

		free(delays);
		free(nm);
	}

	/* Use ofps to measure the stats of the points */
	/* Note that if new_ofps() fails it will exit() */
	if (verb > 1
     && di <= 4
	 && (userand || useqrand || usedsim || usepsim || uselat)) {
		ofps *s;
		printf("Computing device space point stats:\n");
		if ((s = new_ofps(verb, di, uilimit, fxno, 0, 0.0, 0.0, 0.0, 0.0, fxlist, fxno,
	           (void(*)(void *, double *, double *))pdata->dev_to_perc, (void *)pdata)) == NULL) {
			printf("Failed to compute stats\n");
		} else {
			s->stats(s);
			printf("Max distance stats: Min = %f, Average = %f, Max = %f\n",s->mn,s->av,s->mx);
			s->del(s);
		}
	}

	/* Add the eight entries in the second table. */
	/* These are legal device values that we think may */
	/* give all combinations of min/max CMY density values. */
	/* These are chosen from for DTP51, DTP41, i1Pro, ColorMunki etc. */
	/* patch separators. */
	{
		int i;

		pp->add_kword(pp, 1, "DENSITY_EXTREME_VALUES", "8", NULL);

		for (i = 0; i < 8; i++) {
			int e;
			double den[4], val[MXTD], XYZ[3];
			cgats_set_elem ary[1 + MXTD + 3];

			/* Setup target density combination */
			for (e = 0; e < 3; e++) {
				if (i & (1 << e)) 
					den[e] = 2.5;
				else
					den[e] = -0.5;
			}

			/* Lookup device values for target density */
			tpdata->den_to_dev(tpdata, val, den);	

			/* Do a simple ink limit */
			tpdata->limit_ink(tpdata, val);

			ary[0].i = i;

			if (xmask == nmask) {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * val[e];
			} else {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * (1.0 - val[e]);
			}
			tpdata->dev_to_XYZ(tpdata, XYZ, val);		/* Add expected XYZ */
			ary[1 + di + 0].d = 100.0 * XYZ[0];
			ary[1 + di + 1].d = 100.0 * XYZ[1];
			ary[1 + di + 2].d = 100.0 * XYZ[2];

			pp->add_setarr(pp, 1, ary);

		}
	}

	/* Add the nine entries in the third table. */
	/* These are legal device values that we calculate */
	/* give all combinations of typical CMY device values + 50% CMY */
	/* These are typically use for DTP20 bar coding. */
	{
		int i;
	
		icxColorantLu *ftarg = NULL;

		/* If not possible to use native space, use fake CMY */
		if ((nmask & ICX_CMYK) != ICX_CMYK
		 && (nmask & ICX_CMY) != ICX_CMY
		 && (nmask & ICX_RGB) != ICX_RGB) {
			if ((ftarg = new_icxColorantLu(ICX_CMY)) == NULL)
				error ("Creation of xcolorant lu object failed");
		}
		
		pp->add_kword(pp, 2, "DEVICE_COMBINATION_VALUES", "9", NULL);

		for (i = 0; i < 9; i++) {
			int e;
			double val[MXTD], lab[3], XYZ[3];
			cgats_set_elem ary[1 + MXTD + 3];

			for (e = 0; e < di; e++)
				val[e] = 0.0;

			/* Setup target device combination */
			/* Order must be White, Cyan, Magenta, Blue Yellow Green Red Black */
			if (ftarg != NULL || (nmask & ICX_CMY) == ICX_CMY) {
				for (e = 0; e < 3; e++) {
					if (i & (1 << e)) 
						val[e] = 1.0;
					else
						val[e] = 0.0;
				}
				if (i == 7)
					val[3] = 1.0;
				if (i == 8) {			/* Special 50/50/50 grey for DTP20 */
					val[0] = val[1] = val[2] = 0.5;
					val[3] = 0.0;
				}

			} else {	/* RGB like */
				for (e = 0; e < 3; e++) {
					if (i & (1 << e)) 
						val[e] = 0.0;
					else
						val[e] = 1.0;
				}
				if (i == 8)
					val[0] = val[1] = val[2] = 0.5;
			}
			
			/* Apply extra power to device values (??) */
			for (e = 0; e < di; e++)
				val[e] = icx_powlike(val[e], xpow);

			/* If target space isn't something we recognise, convert it */
			if (ftarg != NULL) {
				ftarg->dev_to_rLab(ftarg, lab, val);
				tpdata->rLab_to_dev(tpdata, val, lab);	
			}

			/* Do a simple ink limit */
			tpdata->limit_ink(tpdata, val);

			ary[0].i = i;
			if (xmask == nmask) {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * val[e];
			} else {
				for (e = 0; e < di; e++)
					ary[1 + e].d = 100.0 * (1.0 - val[e]);
			}

			tpdata->dev_to_XYZ(tpdata, XYZ, val);		/* Add expected XYZ */
			ary[1 + di + 0].d = 100.0 * XYZ[0];
			ary[1 + di + 1].d = 100.0 * XYZ[1];
			ary[1 + di + 2].d = 100.0 * XYZ[2];

			pp->add_setarr(pp, 2, ary);
		}

		if (ftarg != NULL)
			ftarg->del(ftarg);
	}

	ttime = clock() - stime;
	if (verb) {
		printf("Total number of patches = %d\n",pp->t[0].nsets);
		if (id < (1 + (1 << di)))
			printf("WARNING : not enough patches for %d channels, need at least %d\n",di,(1 + (1 << di)));
		printf("Execution time = %f seconds\n",ttime/(double)CLOCKS_PER_SEC);
	}

	if (pp->write_name(pp, fname))
		error("Write error : %s",pp->e.m);

#ifdef VRML_DIAG		/* Dump a VRML/X3D of the resulting points */
	if (dumpvrml & 1) {	/* Lab space */
		vrml *wrl;
		int nsets = pp->t[0].nsets;
		double rad;
		double dev[MXTD], Lab[3], col[3];
		int doaxes = 1;					/* Do axes */

		if ((wrl = new_vrml(wlname, doaxes, 0)) == NULL)
			error("new_vrml failed for '%s%s'",wlname,vrml_ext());

		/* Fudge sphere diameter */
		rad = 15.0/pow(nsets, 1.0/(double)(di <= 3 ? di : 3));

		for (i = 0; i < nsets; i++) {
			/* Re-do any inversion before using dev_to_rLab() */
			if (xmask == nmask) {
				for (j = 0; j < di; j++)
					dev[j] = 0.01 * *((double *)pp->t[0].fdata[i][j + 1]);
			} else {
				for (j = 0; j < di; j++)
					dev[j] = 0.01 * (100.0 - *((double *)pp->t[0].fdata[i][j + 1]));
			}
			pdata->dev_to_rLab(pdata, Lab, dev);
			wrl->Lab2RGB(wrl, col, Lab);

			wrl->add_marker(wrl, Lab, col, rad);
		}
		wrl->del(wrl);		/* Write file and delete */
	}
	if (dumpvrml & 2) {	/* Device space */
		vrml *wrl;
		int nsets = pp->t[0].nsets;
		double rad;
		double dev[MXTD], idev[MXTD], Lab[3], col[3];

		wrl = new_vrml(wdname, 0, 0);

		/* Fudge sphere diameter */
		rad = 15.0/pow(nsets, 1.0/(double)(di <= 3 ? di : 3));

		for (i = 0; i < nsets; i++) {

			/* Re-do any inversion before using dev_to_rLab() */
			if (xmask == nmask) {
				for (j = 0; j < di; j++)
					idev[j] = dev[j] = 0.01 * *((double *)pp->t[0].fdata[i][j + 1]);
			} else {
				for (j = 0; j < di; j++) {
					dev[j] = 0.01 * *((double *)pp->t[0].fdata[i][j + 1]);
					idev[j] = 1.0 - dev[j];
				}
			}

			pdata->dev_to_rLab(pdata, Lab, idev);
			wrl->Lab2RGB(wrl, col, Lab);

			/* Fudge device locations into "Lab" space */
			Lab[0] = 100.0 * dev[0];
			Lab[1] = 100.0 * dev[1] - 50.0;
			Lab[2] = 100.0 * dev[2] - 50.0;

			wrl->add_marker(wrl, Lab, col, rad);
		}
		wrl->del(wrl);		/* Write file and delete */
	}
#endif /* VRML_DIAG */

	pdata->del(pdata);	/* Cleanup perceptual conversion */
	tpdata->del(tpdata);

	free(ident);
	pp->del(pp);		/* Clean up */
	if (fxlist != NULL)
		free(fxlist);

	return 0;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - -  */

/* Compte the display response time */
static double disprespt(cgats *pp, int p1, int p2) {
	double orgb[3], nrgb[3];
	double xdelay = 0.0;

	orgb[0] = *((double *)pp->t[0].fdata[p1][1 + 0]) / 100.0;
	orgb[1] = *((double *)pp->t[0].fdata[p1][1 + 1]) / 100.0;
	orgb[2] = *((double *)pp->t[0].fdata[p1][1 + 2]) / 100.0;

	nrgb[0] = *((double *)pp->t[0].fdata[p2][1 + 0]) / 100.0;
	nrgb[1] = *((double *)pp->t[0].fdata[p2][1 + 1]) / 100.0;
	nrgb[2] = *((double *)pp->t[0].fdata[p2][1 + 2]) / 100.0;

	xdelay = disp_settle_time(orgb, nrgb, DISPLAY_RISE_TIME, DISPLAY_FALL_TIME, DISPLAY_SETTLE_AIM);

	return xdelay;
}



