summaryrefslogtreecommitdiff
path: root/spectro/i1pro_imp.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-09-01 13:56:46 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-09-01 13:56:46 +0200
commit22f703cab05b7cd368f4de9e03991b7664dc5022 (patch)
tree6f4d50beaa42328e24b1c6b56b6ec059e4ef21a5 /spectro/i1pro_imp.c
Initial import of argyll version 1.5.1-8debian/1.5.1-8
Diffstat (limited to 'spectro/i1pro_imp.c')
-rw-r--r--spectro/i1pro_imp.c12093
1 files changed, 12093 insertions, 0 deletions
diff --git a/spectro/i1pro_imp.c b/spectro/i1pro_imp.c
new file mode 100644
index 0000000..2211bd4
--- /dev/null
+++ b/spectro/i1pro_imp.c
@@ -0,0 +1,12093 @@
+
+/*
+ * Argyll Color Correction System
+ *
+ * Gretag i1Pro implementation functions
+ *
+ * Author: Graeme W. Gill
+ * Date: 24/11/2006
+ *
+ * Copyright 2006 - 2013 Graeme W. Gill
+ * All rights reserved.
+ *
+ * This material is licenced under the GNU GENERAL PUBLIC LICENSE Version 2 or later :-
+ * see the License2.txt file for licencing details.
+ */
+
+/*
+ If you make use of the instrument driver code here, please note
+ that it is the author(s) of the code who take responsibility
+ for its operation. Any problems or queries regarding driving
+ instruments with the Argyll drivers, should be directed to
+ the Argyll's author(s), and not to any other party.
+
+ If there is some instrument feature or function that you
+ would like supported here, it is recommended that you
+ contact Argyll's author(s) first, rather than attempt to
+ modify the software yourself, if you don't have firm knowledge
+ of the instrument communicate protocols. There is a chance
+ that an instrument could be damaged by an incautious command
+ sequence, and the instrument companies generally cannot and
+ will not support developers that they have not qualified
+ and agreed to support.
+ */
+
+/* TTBD:
+
+ Some things probably aren't quite correct:
+ The way the sensor saturation and optimal target is
+ computed probably doesn't account for the dark level
+ correctly, since the targets are in sensor value,
+ but the comparison is done after subtracting black ??
+ See the Munki implementation for an approach to fix this ??
+
+ It should be possible to add a refresh-display calibration
+ routine based on an emissive scan + the auto-correlation
+ (see i1d3.c). Whether this will noticably improve repeatibility
+ remains to be seen.
+*/
+
+/*
+ Notes:
+
+ Naming of spectral values:
+
+ sensor - the 16 bit values from the sensor including any dummy/shielded values
+ raw - the floating point values of the spectral section
+ absraw - raw after scaling for integration time and gain settings.
+
+ The Rev D seems to die if it is ever given a GET_STATUS. This is why
+ the WinUSB driver can't be used with it.
+
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h>
+#include <math.h>
+#if defined(UNIX)
+# include <utime.h>
+#else
+# include <sys/utime.h>
+#endif
+#include <sys/stat.h>
+#ifndef SALONEINSTLIB
+#include "copyright.h"
+#include "aconfig.h"
+#include "numlib.h"
+#include "rspl.h"
+#else /* SALONEINSTLIB */
+#include <fcntl.h>
+#include "sa_config.h"
+#include "numsup.h"
+#include "rspl1.h"
+#endif /* SALONEINSTLIB */
+#include "xspect.h"
+#include "insttypes.h"
+#include "conv.h"
+#include "icoms.h"
+#include "sort.h"
+
+/* Configuration */
+#define ENABLE_2 /* [Def] Enable i1pro2/Rev E driver code, else treat i1pro2 as i1pro */
+#undef USE_HIGH_GAIN_MODE /* [Und] Make use of high gain mode in Rev A-D mode */
+#define USE_THREAD /* Need to use thread, or there are 1.5 second internal */
+ /* instrument delays ! */
+#undef WAIT_FOR_DELAY_TRIGGER /* [Und] Hack to diagnose threading problems */
+#undef ENABLE_WRITE /* [Und] Enable writing of calibration and log data to the EEProm */
+#define ENABLE_NONVCAL /* [Def] Enable saving calibration state between program runs in a file */
+#define ENABLE_NONLINCOR /* [Def] Enable non-linear correction */
+#define WLCALTOUT (24 * 60 * 60) /* [24 Hrs] Wavelength calibration timeout in seconds */
+#define DCALTOUT ( 60 * 60) /* [60 Minuites] Dark Calibration timeout in seconds */
+#define DCALTOUT2 ( 1 * 60 * 60) /* [1 Hr] i1pro2 Dark Calibration timeout in seconds */
+#define WCALTOUT ( 1 * 60 * 60) /* [1 Hr] White Calibration timeout in seconds */
+#define MAXSCANTIME 15.0 /* [15] Maximum scan time in seconds */
+#define SW_THREAD_TIMEOUT (10 * 60.0) /* [10 Min] Switch read thread timeout */
+
+#define SINGLE_READ /* [Def] Use a single USB read for scan to eliminate latency issues. */
+#define HIGH_RES /* [Def] Enable high resolution spectral mode code. Dissable */
+ /* to break dependency on rspl library. */
+
+/* Debug [Und] */
+#undef DEBUG /* Turn on debug printfs */
+#undef PLOT_DEBUG /* Use plot to show readings & processing */
+#undef PLOT_REFRESH /* Plot refresh rate measurement info */
+#undef DUMP_SCANV /* Dump scan readings to a file "i1pdump.txt" */
+#undef DUMP_DARKM /* Append raw dark readings to file "i1pddump.txt" */
+#undef APPEND_MEAN_EMMIS_VAL /* Append averaged uncalibrated reading to file "i1pdump.txt" */
+#undef TEST_DARK_INTERP /* Test out the dark interpolation (need DEBUG for plot) */
+#undef PATREC_DEBUG /* Print & Plot patch/flash recognition information */
+#undef PATREC_ALLBANDS /* Plot all bands of scan */
+#undef IGNORE_WHITE_INCONS /* Ignore define reference reading inconsistency */
+#undef HIGH_RES_DEBUG
+#undef HIGH_RES_PLOT
+#undef PLOT_BLACK_SUBTRACT /* Plot temperature corrected black subtraction */
+#undef FAKE_AMBIENT /* Fake the ambient mode for a Rev A */
+
+#define MATCH_SPOT_OMD /* [Def] Match Original Manufacturers Driver. Reduce */
+ /* integration time and lamp turn on time */
+
+#define DISP_INTT 2.0 /* Seconds per reading in display spot mode */
+ /* More improves repeatability in dark colors, but limits */
+ /* the maximum brightness level befor saturation. */
+ /* A value of 2.0 seconds has a limit of about 110 cd/m^2 */
+#define DISP_INTT2 0.8 /* High brightness display spot mode seconds per reading, */
+ /* Should be good up to 275 cd/m^2 */
+#define DISP_INTT3 0.3 /* High brightness display spot mode seconds per reading, */
+ /* Should be good up to 700 cd/m^2 */
+
+#define ADARKINT_MAX 2.0 /* Max cal time for adaptive dark cal */
+#define ADARKINT_MAX2 4.0 /* Max cal time for adaptive dark cal Rev E or no high gain */
+
+#define EMIS_SCALE_FACTOR 1.0 /* Emission mode scale factor */
+#define AMB_SCALE_FACTOR (1.0/3.141592654) /* Ambient mode scale factor - convert */
+ /* from Lux to Lux/PI */
+ /* These factors get the same behaviour as the GMB drivers. */
+
+#define NSEN_MAX 140 /* Maximum nsen value we can cope with */
+
+/* High res mode settings */
+#define HIGHRES_SHORT 350
+#define HIGHRES_LONG 740
+#define HIGHRES_WIDTH (10.0/3.0) /* (The 3.3333 spacing and lanczos2 seems a good combination) */
+#define HIGHRES_REF_MIN 375.0 /* Too much stray light below this in reflective mode */
+ /* (i1pro2 could go lower with different correction) */
+
+#include "i1pro.h"
+#include "i1pro_imp.h"
+
+/* - - - - - - - - - - - - - - - - - - */
+#define LAMP_OFF_TIME 1500 /* msec to make sure lamp is dark for dark measurement */
+#define PATCH_CONS_THR 0.1 /* Dark measurement consistency threshold */
+#define TRIG_DELAY 10 /* Measure trigger delay to allow pending read, msec */
+
+/* - - - - - - - - - - - - - - - - - - */
+
+#if defined(DEBUG) || defined(PLOT_DEBUG) || defined(PATREC_DEBUG)
+# include <plot.h>
+#endif
+
+
+#if defined(DEBUG) || defined(PLOT_DEBUG) || defined(HIGH_RES_PLOT) || defined(PATREC_DEBUG)
+static int disdebplot = 0;
+
+#define DISDPLOT disdebplot = 1;
+#define ENDPLOT disdebplot = 0;
+
+#else
+
+#define DISDPLOT
+#define ENDPLOT
+
+#endif /* DEBUG */
+
+#if defined(DEBUG) || defined(PLOT_DEBUG) || defined(PATREC_DEBUG)
+/* ============================================================ */
+/* Debugging support */
+
+/* Plot a CCD spectra */
+void plot_raw(double *data) {
+ int i;
+ double xx[NSEN_MAX];
+ double yy[NSEN_MAX];
+
+ if (disdebplot)
+ return;
+
+ for (i = 0; i < 128; i++) {
+ xx[i] = (double)i;
+ yy[i] = data[i];
+ }
+ do_plot(xx, yy, NULL, NULL, 128);
+}
+
+/* Plot two CCD spectra */
+void plot_raw2(double *data1, double *data2) {
+ int i;
+ double xx[128];
+ double y1[128];
+ double y2[128];
+
+ if (disdebplot)
+ return;
+
+ for (i = 0; i < 128; i++) {
+ xx[i] = (double)i;
+ y1[i] = data1[i];
+ y2[i] = data2[i];
+ }
+ do_plot(xx, y1, y2, NULL, 128);
+}
+
+/* Plot a converted spectra */
+void plot_wav(i1proimp *m, int hires, double *data) {
+ int i;
+ double xx[128];
+ double yy[128];
+
+ if (disdebplot)
+ return;
+
+ for (i = 0; i < m->nwav[hires]; i++) {
+ xx[i] = XSPECT_WL(m->wl_short[hires], m->wl_long[hires], m->nwav[hires], i);
+ yy[i] = data[i];
+ }
+ do_plot(xx, yy, NULL, NULL, m->nwav[hires]);
+}
+
+/* Plot two converted spectra for the current res. mode */
+void plot_wav_2(i1proimp *m, int hires, double *data1, double *data2) {
+ int i;
+ double xx[128];
+ double y1[128];
+ double y2[128];
+
+ if (disdebplot)
+ return;
+
+ for (i = 0; i < m->nwav[hires]; i++) {
+ xx[i] = XSPECT_WL(m->wl_short[hires], m->wl_long[hires], m->nwav[hires], i);
+ y1[i] = data1[i];
+ y2[i] = data2[i];
+ }
+ do_plot(xx, y1, y2, NULL, m->nwav[hires]);
+}
+
+#endif /* PLOT_DEBUG */
+
+/* ============================================================ */
+
+/* Implementation struct */
+
+/* Add an implementation structure */
+i1pro_code add_i1proimp(i1pro *p) {
+ i1proimp *m;
+
+ if ((m = (i1proimp *)calloc(1, sizeof(i1proimp))) == NULL) {
+ a1logd(p->log,1,"add_i1proimp malloc %ld bytes failed (1)\n",sizeof(i1proimp));
+ return I1PRO_INT_MALLOC;
+ }
+ m->p = p;
+
+ /* EEProm data store */
+ if ((m->data = new_i1data(m)) == NULL)
+ return I1PRO_INT_CREATE_EEPROM_STORE;
+
+ m->lo_secs = 2000000000; /* A very long time */
+ m->msec = msec_time();
+
+ p->m = (void *)m;
+ return I1PRO_OK;
+}
+
+/* Shutdown instrument, and then destroy */
+/* implementation structure */
+void del_i1proimp(i1pro *p) {
+
+ a1logd(p->log,5,"i1pro_del called\n");
+
+#ifdef ENABLE_NONVCAL
+ /* Touch it so that we know when the instrument was last open */
+ i1pro_touch_calibration(p);
+#endif /* ENABLE_NONVCAL */
+
+ if (p->m != NULL) {
+ int i, j;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s;
+ i1pro_code ev;
+
+ if (p->itype != instI1Pro2 && (ev = i1pro_update_log(p)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_update_log: Updating the cal and log parameters to"
+ " EEProm failed failed\n");
+ }
+
+ /* i1pro_terminate_switch() seems to fail on a rev A & Rev C ?? */
+ if (m->th != NULL) { /* Terminate switch monitor thread */
+ m->th_term = 1; /* Tell thread to exit on error */
+ i1pro_terminate_switch(p);
+
+ for (i = 0; m->th_termed == 0 && i < 5; i++)
+ msec_sleep(50); /* Wait for thread to terminate */
+ if (i >= 5) {
+ a1logd(p->log,5,"i1pro switch thread termination failed\n");
+ }
+ m->th->del(m->th);
+ usb_uninit_cancel(&m->cancelt); /* Don't need cancel token now */
+ }
+ a1logd(p->log,5,"i1pro switch thread terminated\n");
+
+ /* Free any per mode data */
+ for (i = 0; i < i1p_no_modes; i++) {
+ s = &m->ms[i];
+
+ free_dvector(s->dark_data, -1, m->nraw-1);
+ free_dvector(s->dark_data2, -1, m->nraw-1);
+ free_dvector(s->dark_data3, -1, m->nraw-1);
+ free_dvector(s->white_data, -1, m->nraw-1);
+ free_dmatrix(s->idark_data, 0, 3, -1, m->nraw-1);
+
+ free_dvector(s->cal_factor[0], 0, m->nwav[0]-1);
+ free_dvector(s->cal_factor[1], 0, m->nwav[1]-1);
+ }
+
+ /* Free EEProm key data */
+ if (m->data != NULL)
+ m->data->del(m->data);
+
+ /* Free all Rev E and high res raw2wav filters */
+ for (i = 0; i < 2; i++) {
+ for (j = 0; j < 2; j++) {
+ if (m->mtx_c[i][j].index != NULL)
+ free(m->mtx_c[i][j].index);
+ if (m->mtx_c[i][j].nocoef != NULL)
+ free(m->mtx_c[i][j].nocoef);
+ if (m->mtx_c[i][j].coef != NULL)
+ free(m->mtx_c[i][j].coef);
+ }
+ }
+
+ /* Free RevE straylight arrays */
+ for (i = 0; i < 2; i++) {
+ if (m->straylight[i] != NULL)
+ free_dmatrix(m->straylight[i], 0, m->nwav[i]-1, 0, m->nwav[i]-1);
+ }
+
+ /* RevA-D high res. recal support */
+ if (m->raw2wav != NULL)
+ m->raw2wav->del(m->raw2wav);
+
+ free(m);
+ p->m = NULL;
+ }
+}
+
+/* ============================================================ */
+/* High level functions */
+
+/* Initialise our software state from the hardware */
+i1pro_code i1pro_imp_init(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ unsigned char *eeprom; /* EEProm contents, i1pro = half, i1pro2 = full */
+ int len = 8192;
+
+ a1logd(p->log,5,"i1pro_init:\n");
+
+ /* Revert to i1pro if i1pro2 driver is not enabled */
+ if (p->itype == instI1Pro2
+#ifdef ENABLE_2
+ && getenv("ARGYLL_DISABLE_I1PRO2_DRIVER") != NULL /* Disabled by environment */
+#endif
+ ) {
+ p->itype = instI1Pro;
+ }
+
+ if (p->itype != instI1Monitor
+ && p->itype != instI1Pro
+ && p->itype != instI1Pro2)
+ return I1PRO_UNKNOWN_MODEL;
+
+ m->trig = inst_opt_trig_user;
+ m->scan_toll_ratio = 1.0;
+
+ /* Take conservative approach to when the light was last on. */
+ /* Assume it might have been on right before init was called again. */
+ m->slamponoff = msec_time();
+ m->llampoffon = msec_time();
+ m->llamponoff = msec_time();
+
+ if ((ev = i1pro_reset(p, 0x1f)) != I1PRO_OK)
+ return ev;
+
+ usb_init_cancel(&m->cancelt); /* Init cancel token */
+
+#ifdef USE_THREAD
+ /* Setup the switch monitoring thread */
+ if ((m->th = new_athread(i1pro_switch_thread, (void *)p)) == NULL)
+ return I1PRO_INT_THREADFAILED;
+#endif
+
+ /* Get the current misc. status, fwrev etc */
+ if ((ev = i1pro_getmisc(p, &m->fwrev, NULL, &m->maxpve, NULL, &m->powmode)) != I1PRO_OK)
+ return ev;
+ a1logd(p->log,2,"Firmware rev = %d, max +ve value = 0x%x\n",m->fwrev, m->maxpve);
+
+ if (p->itype == instI1Pro2 && m->fwrev < 600) { /* Hmm */
+ a1logd(p->log,2, "Strange, firmware isn't up to i1pro2 but has extra pipe..revert to i1pro driver\n",m->fwrev);
+ p->itype = instI1Pro;
+ }
+
+ /* Get the EEProm size */
+ m->eesize = 8192; /* Rev A..D */
+ if (p->itype == instI1Pro2) {
+#ifdef NEVER
+// ~~99 Hmm. makes it worse. Why ???
+// /* Make sure LED sequence is finished, because it interferes with EEProm read! */
+// if ((ev = i1pro2_indLEDoff(p)) != I1PRO_OK)
+// return ev;
+#endif
+
+ if ((ev = i1pro2_geteesize(p, &m->eesize)) != I1PRO_OK) {
+ return ev;
+ }
+
+ }
+
+ if (m->eesize < 8192) {
+ a1logd(p->log,2,"Strange, EEProm size is < 8192!\n",m->fwrev);
+ return I1PRO_HW_EE_SIZE;
+ }
+
+ if ((eeprom = (unsigned char *)malloc(m->eesize)) == NULL) {
+ a1logd(p->log,1,"Malloc %d bytes for eeprom failed\n",m->eesize);
+ return I1PRO_INT_MALLOC;
+ }
+
+ /* Read the EEProm */
+ if ((ev = i1pro_readEEProm(p, eeprom, 0, m->eesize)) != I1PRO_OK) {
+ free(eeprom);
+ return ev;
+ }
+
+ if (p->itype == instI1Pro2) {
+ /* Get the Chip ID (This doesn't work until after reading the EEProm !) */
+ if ((ev = i1pro2_getchipid(p, m->chipid)) != I1PRO_OK) {
+ free(eeprom);
+ return ev;
+ }
+ }
+
+ /* Parse the i1pro data */
+ if ((ev = m->data->parse_eeprom(m->data, eeprom, m->eesize, 0)) != I1PRO_OK) {
+ free(eeprom);
+ return ev;
+ }
+
+ /* Parse the i1pro2 extra data */
+ if (p->itype == instI1Pro2) {
+ if ((ev = m->data->parse_eeprom(m->data, eeprom, m->eesize, 1)) != I1PRO_OK) {
+ free(eeprom);
+ return ev;
+ }
+ }
+ free(eeprom); eeprom = NULL;
+
+ /* Setup various calibration parameters from the EEprom */
+ {
+ int *ip, i, xcount;
+ unsigned int count;
+ double *dp;
+
+ /* Information about the instrument */
+
+ if ((ip = m->data->get_ints(m->data, &count, key_serno)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->serno = ip[0];
+ a1logd(p->log,2,"Serial number = %d\n",m->serno);
+ sprintf(m->sserno,"%ud",m->serno);
+
+ if ((ip = m->data->get_ints(m->data, &count, key_dom)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->dom = ip[0];
+ a1logd(p->log,2, "Date of manufactur = %d-%d-%d\n",
+ m->dom/1000000, (m->dom/10000) % 100, m->dom % 10000);
+
+ if ((ip = m->data->get_ints(m->data, &count, key_cpldrev)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->cpldrev = ip[0];
+ a1logd(p->log,2,"CPLD rev = %d\n",m->cpldrev);
+
+ if ((ip = m->data->get_ints(m->data, &count, key_capabilities)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->capabilities = ip[0];
+ if (m->capabilities & 0x6000) /* Has ambient */
+ m->capabilities2 |= I1PRO_CAP2_AMBIENT; /* Mimic in capabilities2 */
+ a1logd(p->log,2,"Capabilities flag = 0x%x\n",m->capabilities);
+ if (m->capabilities & 0x6000)
+ a1logd(p->log,2," Can read ambient\n");
+
+ if ((ip = m->data->get_ints(m->data, &count, key_physfilt)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->physfilt = ip[0];
+ if (m->physfilt == 0x82)
+ m->capabilities2 |= I1PRO_CAP2_UV_FILT; /* Mimic in cap 2 */
+ a1logd(p->log,2,"Physical filter flag = 0x%x\n",m->physfilt);
+ if (m->physfilt == 0x80)
+ a1logd(p->log,2," No filter fitted\n");
+ else if (m->physfilt == 0x81)
+ a1logd(p->log,2," Emission only ??\n");
+ else if (m->physfilt == 0x82)
+ a1logd(p->log,2," Is fitted with Ultra Violet Filter\n");
+
+ /* Underlying calibration information */
+
+ m->nsen = 128;
+ m->nraw = 128;
+ if (p->itype == instI1Pro2) {
+ int clkusec, subdiv, xraw, nraw;
+ if ((ev = i1pro2_getmeaschar(p, &clkusec, &xraw, &nraw, &subdiv)) != I1PRO_OK)
+ return ev;
+ m->intclkp2 = clkusec * 1e-6; /* Rev E integration clock period, ie. 36 usec */
+ m->subclkdiv2 = subdiv; /* Rev E sub clock divider, ie. 136 */
+
+ m->nsen = nraw + xraw;
+ if (clkusec != 36 || xraw != 6 || nraw != 128 || subdiv != 136)
+ return I1PRO_HW_UNEX_SPECPARMS;
+
+ if (m->nsen > NSEN_MAX) /* Static allocation assumed */
+ return I1PRO_HW_UNEX_SPECPARMS;
+ }
+ if (m->data->get_ints(m->data, &m->nwav[0], key_mtx_index) == 0)
+ return I1PRO_HW_CALIBINFO;
+ if (m->nwav[0] != 36)
+ return I1PRO_HW_CALIBINFO;
+ m->wl_short[0] = 380.0; /* Normal res. range */
+ m->wl_long[0] = 730.0;
+
+ /* Fill high res in too */
+ m->wl_short[1] = HIGHRES_SHORT;
+ m->wl_long[1] = HIGHRES_LONG;
+ m->nwav[1] = (int)((m->wl_long[1]-m->wl_short[1])/HIGHRES_WIDTH + 0.5) + 1;
+
+ if ((dp = m->data->get_doubles(m->data, &count, key_hg_factor)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->highgain = dp[0];
+ a1logd(p->log,2,"High gain = %.10f\n",m->highgain);
+
+ if ((m->lin0 = m->data->get_doubles(m->data, &m->nlin0, key_ng_lin)) == NULL
+ || m->nlin0 < 1)
+ return I1PRO_HW_CALIBINFO;
+
+ if ((m->lin1 = m->data->get_doubles(m->data, &m->nlin1, key_hg_lin)) == NULL
+ || m->nlin1 < 1)
+ return I1PRO_HW_CALIBINFO;
+
+ if (p->log->debug >= 2) {
+ char oline[200] = { '\000' }, *bp = oline;
+
+ bp += sprintf(bp,"Normal non-lin =");
+ for(i = 0; i < m->nlin0; i++)
+ bp += sprintf(bp," %1.10f",m->lin0[i]);
+ bp += sprintf(bp,"\n");
+ a1logd(p->log,2,oline);
+
+ bp = oline;
+ bp += sprintf(bp,"High Gain non-lin =");
+ for(i = 0; i < m->nlin1; i++)
+ bp += sprintf(bp," %1.10f",m->lin1[i]);
+ bp += sprintf(bp,"\n");
+ a1logd(p->log,2,oline);
+ }
+
+ if ((dp = m->data->get_doubles(m->data, &count, key_min_int_time)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->min_int_time = dp[0];
+
+ /* And then override it */
+ if (p->itype == instI1Pro2) {
+ m->min_int_time = m->subclkdiv2 * m->intclkp2; /* 0.004896 */
+ } else {
+ if (m->fwrev >= 301)
+ m->min_int_time = 0.004716;
+ else
+ m->min_int_time = 0.00884; /* == 1 sub clock */
+ }
+
+ if ((dp = m->data->get_doubles(m->data, &count, key_max_int_time)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->max_int_time = dp[0];
+
+
+ if ((m->mtx_o.index = m->data->get_ints(m->data, &count, key_mtx_index)) == NULL
+ || count != m->nwav[0])
+ return I1PRO_HW_CALIBINFO;
+
+ if ((m->mtx_o.nocoef = m->data->get_ints(m->data, &count, key_mtx_nocoef)) == NULL
+ || count != m->nwav[0])
+ return I1PRO_HW_CALIBINFO;
+
+ for (xcount = i = 0; i < m->nwav[0]; i++) /* Count number expected in matrix coeffs */
+ xcount += m->mtx_o.nocoef[i];
+
+ if ((m->mtx_o.coef = m->data->get_doubles(m->data, &count, key_mtx_coef)) == NULL
+ || count != xcount)
+ return I1PRO_HW_CALIBINFO;
+
+ if ((m->white_ref[0] = m->data->get_doubles(m->data, &count, key_white_ref)) == NULL
+ || count != m->nwav[0]) {
+ if (p->itype != instI1Monitor)
+ return I1PRO_HW_CALIBINFO;
+ m->white_ref[0] = NULL;
+ }
+
+ if ((m->emis_coef[0] = m->data->get_doubles(m->data, &count, key_emis_coef)) == NULL
+ || count != m->nwav[0])
+ return I1PRO_HW_CALIBINFO;
+
+ if ((m->amb_coef[0] = m->data->get_doubles(m->data, &count, key_amb_coef)) == NULL
+ || count != m->nwav[0]) {
+ if (p->itype != instI1Monitor
+ && m->capabilities & 0x6000) /* Expect ambient calibration */
+ return I1PRO_HW_CALIBINFO;
+ m->amb_coef[0] = NULL;
+ }
+ /* Default to original EEProm raw to wav filters values*/
+ m->mtx[0][0] = m->mtx_o; /* Std res reflective */
+ m->mtx[0][1] = m->mtx_o; /* Std res emissive */
+
+ if ((ip = m->data->get_ints(m->data, &count, key_sens_target)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->sens_target = ip[0];
+
+ if ((ip = m->data->get_ints(m->data, &count, key_sens_dark)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->sens_dark = ip[0];
+
+ if ((ip = m->data->get_ints(m->data, &count, key_ng_sens_sat)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->sens_sat0 = ip[0];
+
+ if ((ip = m->data->get_ints(m->data, &count, key_hg_sens_sat)) == NULL || count < 1)
+ return I1PRO_HW_CALIBINFO;
+ m->sens_sat1 = ip[0];
+
+ a1logd(p->log,2,"sens_target %d, sens_dark %d, sens_sat0 %d, sens_sat1 %d\n",
+ m->sens_target, m->sens_dark, m->sens_sat0, m->sens_sat1);
+
+ /* Then read the log data. Don't fatal error if there is a problem with this. */
+ for (;;) {
+
+ /* Total Measure (Emis/Remis/Ambient/Trans/Cal) count */
+ if ((ip = m->data->get_ints(m->data, &count, key_meascount)) == NULL || count < 1)
+ break;
+ m->meascount = ip[0];
+
+ /* Remspotcal last calibration date */
+ if ((ip = m->data->get_ints(m->data, &count, key_caldate)) == NULL || count < 1)
+ break;
+ m->caldate = ip[0];
+
+ /* Remission spot measure count at last Remspotcal. */
+ if ((ip = m->data->get_ints(m->data, &count, key_calcount)) == NULL || count < 1)
+ break;
+ m->calcount = ip[0];
+
+ /* Last remision spot reading integration time */
+ if ((dp = m->data->get_doubles(m->data, &count, key_rpinttime)) == NULL || count < 1)
+ break;
+ m->rpinttime = dp[0];
+
+ /* Remission spot measure count */
+ if ((ip = m->data->get_ints(m->data, &count, key_rpcount)) == NULL || count < 1)
+ break;
+ m->rpcount = ip[0];
+
+ /* Remission scan measure count (??) */
+ if ((ip = m->data->get_ints(m->data, &count, key_acount)) == NULL || count < 1)
+ break;
+ m->acount = ip[0];
+
+ /* Total lamp usage time in seconds (??) */
+ if ((dp = m->data->get_doubles(m->data, &count, key_lampage)) == NULL || count < 1)
+ break;
+ m->lampage = dp[0];
+ a1logd(p->log,3,"Read log information OK\n");
+
+ break;
+ }
+ }
+
+ /* Read Rev E specific keys */
+ if (p->itype == instI1Pro2) {
+ int i, j;
+ double *dp;
+ int *sip;
+ unsigned int count;
+ int *ip;
+
+ /* Capability bits */
+ if ((ip = m->data->get_ints(m->data, &count, key2_capabilities)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ m->capabilities2 = *ip;
+ if (p->log->debug >= 2) {
+ a1logd(p->log,2,"Capabilities2 flag = 0x%x\n",m->capabilities2);
+ if (m->capabilities2 & I1PRO_CAP2_AMBIENT)
+ a1logd(p->log,2," Can read ambient\n");
+ if (m->capabilities2 & I1PRO_CAP2_WL_LED)
+ a1logd(p->log,2," Has Wavelength Calibration LED\n");
+ if (m->capabilities2 & I1PRO_CAP2_UV_LED)
+ a1logd(p->log,2," Has Ultra Violet LED\n");
+ if (m->capabilities2 & I1PRO_CAP2_ZEB_RUL)
+ a1logd(p->log,2," Has Zebra Ruler sensor\n");
+ if (m->capabilities2 & I1PRO_CAP2_IND_LED)
+ a1logd(p->log,2," Has user indicator LEDs\n");
+ if (m->capabilities2 & I1PRO_CAP2_UV_FILT)
+ a1logd(p->log,2," Is fitted with Ultra Violet Filter\n");
+ }
+
+ if (m->capabilities2 & I1PRO_CAP2_WL_LED) {
+ /* wavelength LED calibration integration time (0.56660) */
+ if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_intt)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ m->wl_cal_inttime = *dp;
+
+ /* Wavelength calibration minimum level */
+ if ((ip = m->data->get_ints(m->data, &count, key2_wlcal_minlev)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ /* Normalize it to 1.0 seconds (ie. 500/0.56660) */
+ m->wl_cal_min_level = (double)(*ip) / m->wl_cal_inttime;
+
+ /* wavelength LED measurement expected FWHM in nm */
+ if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_fwhm)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ m->wl_cal_fwhm = *dp;
+
+ /* wavelength LED measurement FWHM tollerance in nm */
+ if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_fwhm_tol)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ m->wl_cal_fwhm_tol = *dp;
+
+ /* wavelength LED reference spectrum */
+ if ((m->wl_led_spec = m->data->get_doubles(m->data, &m->wl_led_count, key2_wlcal_spec)) == NULL)
+ return I1PRO_HW_CALIBINFO;
+
+ /* wavelength LED spectraum reference offset */
+ if ((ip = m->data->get_ints(m->data, &count, key2_wlcal_ooff)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ m->wl_led_ref_off = *ip;
+ /* Hmm. this is odd, but it doesn't work correctly otherwise... */
+ m->wl_led_ref_off--;
+
+ /* wavelength calibration maximum error */
+ if ((dp = m->data->get_doubles(m->data, &count, key2_wlcal_max)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+ m->wl_err_max = *dp;
+ }
+
+ /* CCD bin to wavelength polinomial */
+ if ((m->wlpoly1 = m->data->get_doubles(m->data, &count, key2_wlpoly_1)) == NULL || count != 4)
+ return I1PRO_HW_CALIBINFO;
+
+ if ((m->wlpoly2 = m->data->get_doubles(m->data, &count, key2_wlpoly_2)) == NULL || count != 4)
+ return I1PRO_HW_CALIBINFO;
+
+ /* Stray light compensation. Note that 16 bit numbers are signed. */
+ if ((sip = m->data->get_shorts(m->data, &count, key2_straylight)) == NULL
+ || count != (36 * 36))
+ return I1PRO_HW_CALIBINFO;
+
+ /* stray light scale factor */
+ if ((dp = m->data->get_doubles(m->data, &count, key2_straylight_scale)) == NULL
+ || count != 1)
+ return I1PRO_HW_CALIBINFO;
+
+ /* Convert from ints to floats */
+ m->straylight[0] = dmatrixz(0, 35, 0, 35);
+ for (i = 0; i < 36; i++) {
+ for (j = 0; j < 36; j++) {
+ m->straylight[0][i][j] = *dp * sip[i * 36 + j]/32767.0;
+ if (i == j)
+ m->straylight[0][i][j] += 1.0;
+ }
+
+ }
+
+ if (p->log->debug >= 7) {
+ a1logd(p->log,7,"Stray Light matrix:\n");
+ for(i = 0; i < 36; i++) {
+ double sum = 0.0;
+ for (j = 0; j < 36; j++) {
+ sum += m->straylight[0][i][j];
+ a1logd(p->log,7," Wt %d = %f\n",j, m->straylight[0][i][j]);
+ }
+ a1logd(p->log,7," Sum = %f\n",sum);
+ }
+ }
+
+#ifdef NEVER
+ /* Plot raw2wav polinomials for Rev E */
+ {
+ double *xx;
+ double *y1, *y2; /* Rev E poly1 and poly2 */
+ double d1, d2;
+ int i, k;
+
+ xx = dvector(0, m->nraw); /* X index = raw bin */
+ y1 = dvector(0, m->nraw); /* Y = nm */
+ y2 = dvector(0, m->nraw); /* Y = nm */
+
+ d1 = d2 = 0.0;
+ for (i = 0; i < m->nraw; i++) {
+ double iv, v1, v2;
+ xx[i] = i;
+
+ iv = (double)(128-i);
+
+ for (v1 = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+ v1 = v1 * iv + m->wlpoly1[k];
+ y1[i] = v1;
+ d1 += fabs(y2[i] - yy[i]);
+
+ for (v2 = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+ v2 = v2 * iv + m->wlpoly2[k];
+ y2[i] = v2;
+ d2 += fabs(y3[i] - yy[i]);
+
+// printf("ix %d, poly1 %f, poly2 %f, del12 %f\n",i, y1[i], y2[i], y2[i] - y1[i]);
+ }
+ printf("Avge del of poly1 = %f, poly2 = %f\n",d1/128.0, d2/128.0);
+
+ printf("CCD bin to wavelength mapping of RevE polinomial:\n");
+ do_plot6(xx, y1, y2, NULL, NULL, NULL, NULL, m->nraw);
+ free_dvector(xx, 0, m->nraw);
+ free_dvector(y1, 0, m->nraw);
+ free_dvector(y2, 0, m->nraw);
+ }
+#endif
+
+ }
+
+ /* Set up the current state of each mode */
+ {
+ int i, j;
+ i1pro_state *s;
+
+ /* First set state to basic configuration */
+ /* (We assume it's been zero'd) */
+ for (i = 0; i < i1p_no_modes; i++) {
+ s = &m->ms[i];
+
+ s->mode = i;
+
+ /* Default to an emissive configuration */
+ s->targoscale = 1.0; /* Default full scale */
+ s->targmaxitime = 2.0; /* Maximum integration time to aim for */
+ s->targoscale2 = 0.15; /* Proportion of targoscale to meed etargmaxitime2 (!higain) */
+ s->gainmode = 0; /* Normal gain mode */
+
+ s->inttime = 0.5; /* Integration time */
+ s->lamptime = 0.50; /* Lamp turn on time (up to 1.0 sec is better, */
+
+ s->wl_valid = 0;
+ s->wl_led_off = m->wl_led_ref_off;
+
+ s->dark_valid = 0; /* Dark cal invalid */
+ s->dark_data = dvectorz(-1, m->nraw-1);
+ s->dark_data2 = dvectorz(-1, m->nraw-1);
+ s->dark_data3 = dvectorz(-1, m->nraw-1);
+
+ s->cal_valid = 0; /* Scale cal invalid */
+ s->cal_factor[0] = dvectorz(0, m->nwav[0]-1);
+ s->cal_factor[1] = dvectorz(0, m->nwav[1]-1);
+ s->white_data = dvectorz(-1, m->nraw-1);
+
+ s->idark_valid = 0; /* Dark cal invalid */
+ s->idark_data = dmatrixz(0, 3, -1, m->nraw-1);
+
+ s->min_wl = 0.0; /* No minimum by default */
+
+ s->dark_int_time = DISP_INTT; /* 2.0 */
+ s->dark_int_time2 = DISP_INTT2; /* 0.8 */
+ s->dark_int_time3 = DISP_INTT3; /* 0.3 */
+
+ s->idark_int_time[0] = s->idark_int_time[2] = m->min_int_time;
+ if (p->itype == instI1Pro2) {
+ s->idark_int_time[1] = s->idark_int_time[3] = ADARKINT_MAX2; /* 4.0 */
+ } else {
+#ifdef USE_HIGH_GAIN_MODE
+ s->idark_int_time[1] = s->idark_int_time[3] = ADARKINT_MAX; /* 2.0 */
+#else
+ s->idark_int_time[1] = s->idark_int_time[3] = ADARKINT_MAX2; /* 4.0 */
+#endif
+ }
+
+ s->want_calib = 1; /* Do an initial calibration */
+ s->want_dcalib = 1;
+ }
+
+ /* Then add mode specific settings */
+ for (i = 0; i < i1p_no_modes; i++) {
+ s = &m->ms[i];
+ switch(i) {
+ case i1p_refl_spot:
+ s->targoscale = 1.0; /* Optimised sensor scaling to full */
+ s->reflective = 1;
+ s->adaptive = 1;
+ s->inttime = 0.02366; /* Should get this from the log ?? */
+ s->dark_int_time = s->inttime;
+
+ s->dadaptime = 0.10;
+ s->wadaptime = 0.10;
+#ifdef MATCH_SPOT_OMD
+ s->lamptime = 0.18; /* Lamp turn on time, close to OMD */
+ /* (Not ideal, but partly compensated by calib.) */
+ /* (The actual value the OMD uses is 0.20332) */
+ s->dcaltime = 0.05; /* Longer than the original driver for lower */
+ /* noise, and lamptime has been reduces to */
+ /* compensate. (OMD uses 0.014552) */
+ s->wcaltime = 0.05;
+ s->dreadtime = 0.05;
+ s->wreadtime = 0.05;
+#else
+ s->lamptime = 0.5; /* This should give better accuracy, and better */
+ s->dcaltime = 0.5; /* match the scan readings. Difference is about */
+ s->wcaltime = 0.5; /* 0.1 DE though, but would be lost in the */
+ s->dreadtime = 0.5; /* repeatability noise... */
+ s->wreadtime = 0.5;
+#endif
+ s->maxscantime = 0.0;
+ s->min_wl = HIGHRES_REF_MIN;/* Too much stray light below this */
+ /* given low illumination < 375nm */
+ break;
+ case i1p_refl_scan:
+ s->reflective = 1;
+ s->scan = 1;
+ s->adaptive = 1;
+ s->inttime = m->min_int_time; /* Maximize scan rate */
+ s->dark_int_time = s->inttime;
+ if (m->fwrev >= 301) /* (We're not using scan targoscale though) */
+ s->targoscale = 0.25;
+ else
+ s->targoscale = 0.5;
+
+ s->lamptime = 0.5; /* Lamp turn on time - lots to match scan */
+ s->dadaptime = 0.10;
+ s->wadaptime = 0.10;
+ s->dcaltime = 0.5;
+ s->wcaltime = 0.5;
+ s->dreadtime = 0.10;
+ s->wreadtime = 0.10;
+ s->maxscantime = MAXSCANTIME;
+ s->min_wl = HIGHRES_REF_MIN; /* Too much stray light below this */
+ break;
+
+ case i1p_emiss_spot_na: /* Emissive spot not adaptive */
+ s->targoscale = 0.90; /* Allow extra 10% margine for drift */
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+ s->cal_valid = 1;
+ s->emiss = 1;
+ s->adaptive = 0;
+
+ s->inttime = DISP_INTT; /* Default disp integration time (ie. 2.0 sec) */
+ s->lamptime = 0.20; /* ???? */
+ s->dark_int_time = s->inttime;
+ s->dark_int_time2 = DISP_INTT2; /* Alternate disp integration time (ie. 0.8) */
+ s->dark_int_time3 = DISP_INTT3; /* Alternate disp integration time (ie. 0.3) */
+
+ s->dadaptime = 0.0;
+ s->wadaptime = 0.10;
+ s->dcaltime = DISP_INTT; /* ie. determines number of measurements */
+ s->dcaltime2 = DISP_INTT2 * 2; /* Make it 1.6 seconds (ie, 2 x 0.8 seconds) */
+ s->dcaltime3 = DISP_INTT3 * 3; /* Make it 0.9 seconds (ie, 3 x 0.3 seconds) */
+ s->wcaltime = 0.0;
+ s->dreadtime = 0.0;
+ s->wreadtime = DISP_INTT;
+ s->maxscantime = 0.0;
+ break;
+ case i1p_emiss_spot:
+ s->targoscale = 0.90; /* Allow extra 10% margine for drift */
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+ s->cal_valid = 1;
+ s->emiss = 1;
+ s->adaptive = 1;
+
+ s->lamptime = 0.20; /* ???? */
+ s->dadaptime = 0.0;
+ s->wadaptime = 0.10;
+ s->dcaltime = 1.0;
+ s->wcaltime = 0.0;
+ s->dreadtime = 0.0;
+ s->wreadtime = 1.0;
+ s->maxscantime = 0.0;
+ break;
+ case i1p_emiss_scan:
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+ s->cal_valid = 1;
+ s->emiss = 1;
+ s->scan = 1;
+ s->adaptive = 1; /* ???? */
+ s->inttime = m->min_int_time; /* Maximize scan rate */
+ s->lamptime = 0.20; /* ???? */
+ s->dark_int_time = s->inttime;
+ if (m->fwrev >= 301)
+ s->targoscale = 0.25; /* (We're not using scan targoscale though) */
+ else
+ s->targoscale = 0.5;
+
+ s->dadaptime = 0.0;
+ s->wadaptime = 0.10;
+ s->dcaltime = 1.0;
+ s->wcaltime = 0.0;
+ s->dreadtime = 0.0;
+ s->wreadtime = 0.10;
+ s->maxscantime = MAXSCANTIME;
+ break;
+
+ case i1p_amb_spot:
+#ifdef FAKE_AMBIENT
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+ s->cal_valid = 1;
+#else
+ if (m->amb_coef[0] != NULL) {
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = AMB_SCALE_FACTOR * m->emis_coef[0][j] * m->amb_coef[0][j];
+ s->cal_valid = 1;
+ }
+#endif
+ s->emiss = 1;
+ s->ambient = 1;
+ s->adaptive = 1;
+
+ s->lamptime = 0.20; /* ???? */
+ s->dadaptime = 0.0;
+ s->wadaptime = 0.10;
+ s->dcaltime = 1.0;
+ s->wcaltime = 0.0;
+ s->dreadtime = 0.0;
+ s->wreadtime = 1.0;
+ s->maxscantime = 0.0;
+ break;
+ case i1p_amb_flash:
+ /* This is intended for measuring flashes */
+#ifdef FAKE_AMBIENT
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = EMIS_SCALE_FACTOR * m->emis_coef[0][j];
+ s->cal_valid = 1;
+#else
+ if (m->amb_coef[0] != NULL) {
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = AMB_SCALE_FACTOR * m->emis_coef[0][j] * m->amb_coef[0][j];
+ s->cal_valid = 1;
+ }
+#endif
+ s->emiss = 1;
+ s->ambient = 1;
+ s->scan = 1;
+ s->adaptive = 0;
+ s->flash = 1;
+
+ s->inttime = m->min_int_time; /* Maximize scan rate */
+ s->lamptime = 0.20; /* ???? */
+ s->dark_int_time = s->inttime;
+ if (m->fwrev >= 301)
+ s->targoscale = 0.25; /* (We're not using scan targoscale though) */
+ else
+ s->targoscale = 0.5;
+
+ s->dadaptime = 0.0;
+ s->wadaptime = 0.10;
+ s->dcaltime = 1.0;
+ s->wcaltime = 0.0;
+ s->dreadtime = 0.0;
+ s->wreadtime = 0.12;
+ s->maxscantime = MAXSCANTIME;
+ break;
+
+ case i1p_trans_spot:
+ s->trans = 1;
+ s->adaptive = 1;
+
+ s->lamptime = 0.20; /* ???? */
+ s->dadaptime = 0.10;
+ s->wadaptime = 0.10;
+ s->dcaltime = 1.0;
+ s->wcaltime = 1.0;
+ s->dreadtime = 0.0;
+ s->wreadtime = 1.0;
+ s->maxscantime = 0.0;
+ s->min_wl = HIGHRES_REF_MIN; /* Too much stray light below this */
+ break;
+ case i1p_trans_scan:
+ s->trans = 1;
+ s->scan = 1;
+ s->adaptive = 0;
+ s->inttime = m->min_int_time; /* Maximize scan rate */
+ s->dark_int_time = s->inttime;
+ if (m->fwrev >= 301) /* (We're not using scan targoscale though) */
+ s->targoscale = 0.25;
+ else
+ s->targoscale = 0.5;
+
+ s->lamptime = 0.20; /* ???? */
+ s->dadaptime = 0.10;
+ s->wadaptime = 0.10;
+ s->dcaltime = 1.0;
+ s->wcaltime = 1.0;
+ s->dreadtime = 0.00;
+ s->wreadtime = 0.10;
+ s->maxscantime = MAXSCANTIME;
+ s->min_wl = HIGHRES_REF_MIN; /* Too much stray light below this */
+ break;
+ }
+ }
+ }
+
+ if (p->itype != instI1Monitor /* Monitor doesn't have reflective cal */
+ && p->itype != instI1Pro2) { /* Rev E mode has different calibration */
+ /* Restore the previous reflective spot calibration from the EEProm */
+ /* Get ready to operate the instrument */
+ if ((ev = i1pro_restore_refspot_cal(p)) != I1PRO_OK)
+ return ev;
+ }
+
+#ifdef ENABLE_NONVCAL
+ /* Restore the all modes calibration from the local system */
+ i1pro_restore_calibration(p);
+ /* Touch it so that we know when the instrument was last opened */
+ i1pro_touch_calibration(p);
+#endif
+
+ /* Get ready to operate the instrument */
+ if ((ev = i1pro_establish_high_power(p)) != I1PRO_OK)
+ return ev;
+
+ /* Get the current measurement parameters (why ?) */
+ if ((ev = i1pro_getmeasparams(p, &m->r_intclocks, &m->r_lampclocks, &m->r_nummeas, &m->r_measmodeflags)) != I1PRO_OK)
+ return ev;
+
+ if (p->log->verb >= 1) {
+ a1logv(p->log,1,"Instrument Type: %s\n",inst_name(p->itype));
+ a1logv(p->log,1,"Serial Number: %d\n",m->serno);
+ a1logv(p->log,1,"Firmware version: %d\n",m->fwrev);
+ a1logv(p->log,1,"CPLD version: %d\n",m->cpldrev);
+ if (p->itype == instI1Pro2)
+ a1logv(p->log,1,"Chip ID: %02x-%02x%02x%02x%02x%02x%02x%02x\n",
+ m->chipid[0], m->chipid[1], m->chipid[2], m->chipid[3],
+ m->chipid[4], m->chipid[5], m->chipid[6], m->chipid[7]);
+ a1logv(p->log,1,"Date manufactured: %d-%d-%d\n",
+ m->dom/1000000, (m->dom/10000) % 100, m->dom % 10000);
+ // Hmm. physfilt == 0x81 for instI1Monitor ???
+ a1logv(p->log,1,"U.V. filter ?: %s\n",m->physfilt == 0x82 ? "Yes" : "No");
+ a1logv(p->log,1,"Measure Ambient ?: %s\n",m->capabilities & 0x6000 ? "Yes" : "No");
+
+ a1logv(p->log,1,"Tot. Measurement Count: %d\n",m->meascount);
+ a1logv(p->log,1,"Remission Spot Count: %d\n",m->rpcount);
+ a1logv(p->log,1,"Remission Scan Count: %d\n",m->acount);
+ a1logv(p->log,1,"Date of last Remission spot cal: %s",ctime(&m->caldate));
+ a1logv(p->log,1,"Remission Spot Count at last cal: %d\n",m->calcount);
+ a1logv(p->log,1,"Total lamp usage: %f\n",m->lampage);
+ }
+
+#ifdef NEVER
+// ~~99 play with LED settings
+ if (p->itype == instI1Pro2) {
+
+ /* Makes it white */
+ unsigned char b2[] = {
+ 0x00, 0x00, 0x00, 0x02,
+
+ 0x00, 0x00, 0x00, 0x0a,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x36, 0x00,
+ 0x00, 0x00, 0x01,
+
+ 0x00, 0x00, 0x00, 0x0a,
+ 0xff, 0xff, 0xff, 0xff,
+ 0x3f, 0x36, 0x40,
+ 0x00, 0x00, 0x01
+ };
+
+ printf("~1 send led sequence length %d\n",sizeof(b2));
+ if ((ev = i1pro2_indLEDseq(p, b2, sizeof(b2))) != I1PRO_OK)
+ return ev;
+ }
+ /* Make sure LED sequence is finished, because it interferes with EEProm read! */
+ if ((ev = i1pro2_indLEDoff(p)) != I1PRO_OK)
+ return ev;
+#endif
+
+ return ev;
+}
+
+/* Return a pointer to the serial number */
+char *i1pro_imp_get_serial_no(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+
+ return m->sserno;
+}
+
+/* Return non-zero if capable of ambient mode */
+int i1pro_imp_ambient(i1pro *p) {
+
+ if (p->inited) {
+ i1proimp *m = (i1proimp *)p->m;
+ if (m->capabilities & 0x6000) /* Expect ambient calibration */
+ return 1;
+#ifdef FAKE_AMBIENT
+ return 1;
+#endif
+ return 0;
+
+ } else {
+ return 0;
+ }
+}
+
+/* Set the measurement mode. It may need calibrating */
+i1pro_code i1pro_imp_set_mode(
+ i1pro *p,
+ i1p_mode mmode, /* Operating mode */
+ inst_mode mode /* Full mode mask for options */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+
+ a1logd(p->log,2,"i1pro_imp_set_mode called with %d\n",mmode);
+ switch(mmode) {
+ case i1p_refl_spot:
+ case i1p_refl_scan:
+ if (p->itype == instI1Monitor)
+ return I1PRO_INT_ILLEGALMODE; /* i1Monitor */
+ /* Fall through */
+ case i1p_emiss_spot_na:
+ case i1p_emiss_spot:
+ case i1p_emiss_scan:
+ case i1p_amb_spot:
+ case i1p_amb_flash:
+ case i1p_trans_spot:
+ case i1p_trans_scan:
+ m->mmode = mmode;
+ break;
+ default:
+ return I1PRO_INT_ILLEGALMODE;
+ }
+ m->spec_en = (mode & inst_mode_spectral) != 0;
+ m->uv_en = 0;
+
+ if (mmode == i1p_refl_spot
+ || mmode == i1p_refl_scan)
+ m->uv_en = (mode & inst_mode_ref_uv) != 0;
+
+ return I1PRO_OK;
+}
+
+/* Return needed and available inst_cal_type's */
+i1pro_code i1pro_imp_get_n_a_cals(i1pro *p, inst_cal_type *pn_cals, inst_cal_type *pa_cals) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *cs = &m->ms[m->mmode];
+ time_t curtime = time(NULL);
+ inst_cal_type n_cals = inst_calt_none;
+ inst_cal_type a_cals = inst_calt_none;
+
+ a1logd(p->log,2,"i1pro_imp_get_n_a_cals: checking mode %d\n",m->mmode);
+
+ /* Timout calibrations that are too old */
+ if (m->capabilities2 & I1PRO_CAP2_WL_LED) {
+ if ((curtime - cs->wldate) > WLCALTOUT) {
+ a1logd(p->log,2,"Invalidating wavelength cal as %d secs from last cal\n",curtime - cs->wldate);
+ cs->wl_valid = 0;
+ }
+ }
+ if ((curtime - cs->iddate) > ((p->itype == instI1Pro) ? DCALTOUT2 : DCALTOUT)) {
+ a1logd(p->log,2,"Invalidating adaptive dark cal as %d secs from last cal\n",curtime - cs->iddate);
+ cs->idark_valid = 0;
+ }
+ if ((curtime - cs->ddate) > ((p->itype == instI1Pro) ? DCALTOUT2 : DCALTOUT)) {
+ a1logd(p->log,2,"Invalidating dark cal as %d secs from last cal\n",curtime - cs->ddate);
+ cs->dark_valid = 0;
+ }
+ if (!cs->emiss && (curtime - cs->cfdate) > WCALTOUT) {
+ a1logd(p->log,2,"Invalidating white cal as %d secs from last cal\n",curtime - cs->cfdate);
+ cs->cal_valid = 0;
+ }
+
+#ifdef NEVER
+ printf("~1 reflective = %d, adaptive = %d, emiss = %d, trans = %d, scan = %d\n",
+ cs->reflective, cs->adaptive, cs->emiss, cs->trans, cs->scan);
+ printf("~1 idark_valid = %d, dark_valid = %d, cal_valid = %d\n",
+ cs->idark_valid,cs->dark_valid,cs->cal_valid);
+ printf("~1 want_calib = %d, want_dcalib = %d, noinitcalib = %d\n",
+ cs->want_calib,cs->want_dcalib, m->noinitcalib);
+#endif /* NEVER */
+
+ if (m->capabilities2 & I1PRO_CAP2_WL_LED) {
+ if (!cs->wl_valid
+ || (cs->want_dcalib && !m->noinitcalib)) // ?? want_dcalib ??
+ n_cals |= inst_calt_wavelength;
+ a_cals |= inst_calt_wavelength;
+ }
+ if (cs->reflective) {
+ if (!cs->dark_valid
+ || (cs->want_dcalib && !m->noinitcalib))
+ n_cals |= inst_calt_ref_dark;
+ a_cals |= inst_calt_ref_dark;
+
+ if (!cs->cal_valid
+ || (cs->want_calib && !m->noinitcalib))
+ n_cals |= inst_calt_ref_white;
+ a_cals |= inst_calt_ref_white;
+ }
+ if (cs->emiss) {
+ if ((!cs->adaptive && !cs->dark_valid)
+ || (cs->adaptive && !cs->idark_valid)
+ || (cs->want_dcalib && !m->noinitcalib))
+ n_cals |= inst_calt_em_dark;
+ a_cals |= inst_calt_em_dark;
+ }
+ if (cs->trans) {
+ if ((!cs->adaptive && !cs->dark_valid)
+ || (cs->adaptive && !cs->idark_valid)
+ || (cs->want_dcalib && !m->noinitcalib))
+ n_cals |= inst_calt_trans_dark;
+ a_cals |= inst_calt_trans_dark;
+
+ if (!cs->cal_valid
+ || (cs->want_calib && !m->noinitcalib))
+ n_cals |= inst_calt_trans_vwhite;
+ a_cals |= inst_calt_trans_vwhite;
+ }
+ if (cs->emiss && !cs->adaptive && !cs->scan) {
+ if (!cs->done_dintsel)
+ n_cals |= inst_calt_emis_int_time;
+ a_cals |= inst_calt_emis_int_time;
+ }
+
+ if (pn_cals != NULL)
+ *pn_cals = n_cals;
+
+ if (pa_cals != NULL)
+ *pa_cals = a_cals;
+
+ a1logd(p->log,3,"i1pro_imp_get_n_a_cals: returning n_cals 0x%x, a_cals 0x%x\n",n_cals, a_cals);
+
+ return I1PRO_OK;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Calibrate for the current mode. */
+/* Request an instrument calibration of the current mode. */
+i1pro_code i1pro_imp_calibrate(
+ i1pro *p,
+ inst_cal_type *calt, /* Calibration type to do/remaining */
+ inst_cal_cond *calc, /* Current condition/desired condition */
+ char id[CALIDLEN] /* Condition identifier (ie. white reference ID) */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ int mmode = m->mmode;
+ i1pro_state *cs = &m->ms[m->mmode];
+ int sx1, sx2, sx;
+ time_t cdate = time(NULL);
+ int nummeas = 0;
+ int ltocmode = 0; /* 1 = Lamp turn on compensation mode */
+ int i, k;
+ inst_cal_type needed, available;
+
+ a1logd(p->log,2,"i1pro_imp_calibrate called with calt 0x%x, calc 0x%x\n",*calt, *calc);
+
+ if ((ev = i1pro_imp_get_n_a_cals(p, &needed, &available)) != I1PRO_OK)
+ return ev;
+
+ /* Translate inst_calt_all/needed into something specific */
+ if (*calt == inst_calt_all
+ || *calt == inst_calt_needed
+ || *calt == inst_calt_available) {
+ if (*calt == inst_calt_all)
+ *calt = (needed & inst_calt_n_dfrble_mask) | inst_calt_ap_flag;
+ else if (*calt == inst_calt_needed)
+ *calt = needed & inst_calt_n_dfrble_mask;
+ else if (*calt == inst_calt_available)
+ *calt = available & inst_calt_n_dfrble_mask;
+
+ a1logd(p->log,4,"i1pro_imp_calibrate: doing calt 0x%x\n",calt);
+
+ if ((*calt & inst_calt_n_dfrble_mask) == 0) /* Nothing todo */
+ return I1PRO_OK;
+ }
+
+ /* See if it's a calibration we understand */
+ if (*calt & ~available & inst_calt_all_mask) {
+ return I1PRO_UNSUPPORTED;
+ }
+
+ if (*calt & inst_calt_ap_flag) {
+ sx1 = 0; sx2 = i1p_no_modes; /* Go through all the modes */
+ } else {
+ sx1 = m->mmode; sx2 = sx1 + 1; /* Just current mode */
+ }
+
+ /* Go through the modes we are going to cover */
+ for (sx = sx1; sx < sx2; sx++) {
+ i1pro_state *s = &m->ms[sx];
+ m->mmode = sx; /* A lot of functions we call rely on this */
+
+ a1logd(p->log,2,"\nCalibrating mode %d\n", s->mode);
+
+ /* Sanity check scan mode settings, in case something strange */
+ /* has been restored from the persistence file. */
+ if (s->scan && s->inttime > (2.1 * m->min_int_time)) {
+ s->inttime = m->min_int_time; /* Maximize scan rate */
+ }
+
+ /* Wavelength calibration: */
+ if ((m->capabilities2 & I1PRO_CAP2_WL_LED)
+ && (*calt & (inst_calt_wavelength | inst_calt_ap_flag))
+ && (*calc == inst_calc_man_ref_white
+ || *calc == inst_calc_man_am_dark)) {
+ double *wlraw;
+ double optscale;
+ double *abswav;
+
+ a1logd(p->log,2,"\nDoing wavelength calibration\n");
+
+ wlraw = dvectorz(-1, m->nraw-1);
+
+ if ((ev = i1pro2_wl_measure(p, wlraw, &optscale, &m->wl_cal_inttime, 1.0)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro2_wl_measure() failed\n");
+ return ev;
+ }
+
+ /* Find the best fit of the measured values to the reference spectrum */
+ if ((ev = i1pro2_match_wl_meas(p, &cs->wl_led_off, wlraw)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro2_match_wl_meas() failed\n");
+ return ev;
+ }
+
+ free_dvector(wlraw, -1, m->nraw-1);
+
+ /* Compute normal res. reflective wavelength corrected filters */
+ if ((ev = i1pro2_compute_wav_filters(p, 1)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro2_compute_wav_filters() failed\n");
+ return ev;
+ }
+
+ /* Compute normal res. emissive/transmissive wavelength corrected filters */
+ if ((ev = i1pro2_compute_wav_filters(p, 0)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro2_compute_wav_filters() failed\n");
+ return ev;
+ }
+
+ /* Re-compute high res. wavelength corrected filters */
+ if (m->hr_inited && (ev = i1pro_create_hr(p)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_create_hr() failed\n");
+ return ev;
+ }
+
+ cs->wl_valid = 1;
+ cs->wldate = cdate;
+ *calt &= ~inst_calt_wavelength;
+
+ /* Save the calib to all modes */
+ a1logd(p->log,5,"Saving wavelength calib to similar modes\n");
+ for (i = 0; i < i1p_no_modes; i++) {
+ i1pro_state *ss = &m->ms[i];
+ if (ss == cs)
+ continue;
+ ss->wl_valid = cs->wl_valid;
+ ss->wldate = cs->wldate;
+ ss->wl_led_off = cs->wl_led_off;
+ }
+ }
+
+ /* Fixed int. time black calibration: */
+ /* Reflective uses on the fly black, even for adaptive. */
+ /* Emiss and trans can use single black ref only for non-adaptive */
+ /* using the current inttime & gainmode, while display mode */
+ /* does an extra fallback black cal for bright displays. */
+ if ((*calt & (inst_calt_ref_dark
+ | inst_calt_em_dark
+ | inst_calt_trans_dark | inst_calt_ap_flag))
+ && (*calc == inst_calc_man_ref_white /* Any condition conducive to dark calib */
+ || *calc == inst_calc_man_em_dark
+ || *calc == inst_calc_man_am_dark
+ || *calc == inst_calc_man_trans_dark)
+ && ( s->reflective
+ || (s->emiss && !s->adaptive && !s->scan)
+ || (s->trans && !s->adaptive))) {
+ int stm;
+ int usesdct23 = 0; /* Is a mode that uses dcaltime2 & 3 */
+
+ if (s->emiss && !s->adaptive && !s->scan)
+ usesdct23 = 1;
+
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+
+ a1logd(p->log,2,"\nDoing initial black calibration with dcaltime %f, int_time %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+ stm = msec_time();
+ if ((ev = i1pro_dark_measure(p, s->dark_data,
+ nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ a1logd(p->log,2,"Execution time of dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+
+ /* Special display mode alternate integration time black measurement */
+ if (usesdct23) {
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime2, s->dark_int_time2);
+ a1logd(p->log,2,"Doing 2nd initial black calibration with dcaltime2 %f, dark_int_time2 %f, nummeas %d, gainmode %d\n", s->dcaltime2, s->dark_int_time2, nummeas, s->gainmode);
+ stm = msec_time();
+ if ((ev = i1pro_dark_measure(p, s->dark_data2,
+ nummeas, &s->dark_int_time2, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ a1logd(p->log,2,"Execution time of 2nd dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime3, s->dark_int_time3);
+ a1logd(p->log,2,"Doing 3rd initial black calibration with dcaltime3 %f, dark_int_time3 %f, nummeas %d, gainmode %d\n", s->dcaltime3, s->dark_int_time3, nummeas, s->gainmode);
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime3, s->dark_int_time3);
+ stm = msec_time();
+ if ((ev = i1pro_dark_measure(p, s->dark_data3,
+ nummeas, &s->dark_int_time3, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ a1logd(p->log,2,"Execution time of 3rd dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+ }
+ s->dark_valid = 1;
+ s->want_dcalib = 0;
+ s->ddate = cdate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ *calt &= ~(inst_calt_ref_dark
+ | inst_calt_em_dark
+ | inst_calt_trans_dark);
+
+ /* Save the calib to all similar modes */
+ for (i = 0; i < i1p_no_modes; i++) {
+ i1pro_state *ss = &m->ms[i];
+ if (ss == s || ss->ddate == cdate)
+ continue;
+ if (( s->reflective
+ || (ss->emiss && !ss->adaptive && !ss->scan)
+ || (ss->trans && !ss->adaptive))
+ && ss->dark_int_time == s->dark_int_time
+ && ss->dark_gain_mode == s->dark_gain_mode) {
+
+ ss->dark_valid = s->dark_valid;
+ ss->want_dcalib = s->want_dcalib;
+ ss->ddate = s->ddate;
+ ss->dark_int_time = s->dark_int_time;
+ ss->dark_gain_mode = s->dark_gain_mode;
+ for (k = -1; k < m->nraw; k++)
+ ss->dark_data[k] = s->dark_data[k];
+ /* If this is a mode with dark_data2/3, tranfer it too */
+ if (usesdct23 && ss->emiss && !ss->adaptive && !ss->scan) {
+ ss->dark_int_time2 = s->dark_int_time2;
+ ss->dark_int_time3 = s->dark_int_time2;
+ for (k = -1; k < m->nraw; k++) {
+ ss->dark_data2[k] = s->dark_data2[k];
+ ss->dark_data3[k] = s->dark_data3[k];
+ }
+ }
+ }
+ }
+ }
+
+ /* Emissive scan black calibration: */
+ /* Emsissive scan (flash) uses the fastest possible scan rate (??) */
+ if ((*calt & (inst_calt_em_dark | inst_calt_ap_flag))
+ && (*calc == inst_calc_man_ref_white /* Any condition conducive to dark calib */
+ || *calc == inst_calc_man_em_dark
+ || *calc == inst_calc_man_am_dark
+ || *calc == inst_calc_man_trans_dark)
+ && (s->emiss && !s->adaptive && s->scan)) {
+ int stm;
+
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+
+ a1logd(p->log,2,"\nDoing emissive (flash) black calibration with dcaltime %f, int_time %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+ stm = msec_time();
+ if ((ev = i1pro_dark_measure(p, s->dark_data,
+ nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ a1logd(p->log,2,"Execution time of dark calib time %f sec = %d msec\n",s->inttime,msec_time() - stm);
+
+ s->dark_valid = 1;
+ s->want_dcalib = 0;
+ s->ddate = cdate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ *calt &= ~inst_calt_em_dark;
+
+ /* Save the calib to all similar modes */
+ /* We're assuming they have the same int times */
+ a1logd(p->log,5,"Saving emissive scan black calib to similar modes\n");
+ for (i = 0; i < i1p_no_modes; i++) {
+ i1pro_state *ss = &m->ms[i];
+ if (ss == s || ss->ddate == s->ddate)
+ continue;
+ if (ss->emiss && !ss->adaptive && ss->scan) {
+ ss->dark_valid = s->dark_valid;
+ ss->want_dcalib = s->want_dcalib;
+ ss->ddate = s->ddate;
+ ss->dark_int_time = s->dark_int_time;
+ ss->dark_gain_mode = s->dark_gain_mode;
+ for (k = -1; k < m->nraw; k++)
+ ss->dark_data[k] = s->dark_data[k];
+ }
+ }
+ }
+
+ /* Adaptive black calibration: */
+ /* Deal with an emmissive/transmissive black reference */
+ /* in non-scan mode, where the integration time and gain may vary. */
+ /* The black is interpolated from readings with two extreme integration times */
+ if ((*calt & (inst_calt_ref_dark
+ | inst_calt_em_dark
+ | inst_calt_trans_dark | inst_calt_ap_flag))
+ && (*calc == inst_calc_man_ref_white /* Any condition conducive to dark calib */
+ || *calc == inst_calc_man_em_dark
+ || *calc == inst_calc_man_am_dark
+ || *calc == inst_calc_man_trans_dark)
+ && ((s->emiss && s->adaptive && !s->scan)
+ || (s->trans && s->adaptive && !s->scan))) {
+ int i, j, k;
+
+ a1logd(p->log,2,"\nDoing emis/trans adapative black calibration\n");
+
+ /* Adaptive where we can't measure the black reference on the fly, */
+ /* so bracket it and interpolate. */
+ /* The black reference is probably temperature dependent, but */
+ /* there's not much we can do about this. */
+
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[0]);
+ a1logd(p->log,2,"\nDoing adaptive interpolated black calibration, dcaltime %f, idark_int_time[0] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[0], nummeas, 0);
+ if ((ev = i1pro_dark_measure(p, s->idark_data[0],
+ nummeas, &s->idark_int_time[0], 0)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[1]);
+ a1logd(p->log,2,"Doing adaptive interpolated black calibration, dcaltime %f, idark_int_time[1] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[1], nummeas, 0);
+ if ((ev = i1pro_dark_measure(p, s->idark_data[1],
+ nummeas, &s->idark_int_time[1], 0)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+
+#ifdef USE_HIGH_GAIN_MODE
+ if (p->itype != instI1Pro2) { /* Rev E doesn't have high gain mode */
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[2]);
+ a1logd(p->log,2,"Doing adaptive interpolated black calibration, dcaltime %f, idark_int_time[2] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[2], nummeas, 1);
+ if ((ev = i1pro_dark_measure(p, s->idark_data[2],
+ nummeas, &s->idark_int_time[2], 1)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+
+ a1logd(p->log,2,"Doing adaptive interpolated black calibration, dcaltime %f, idark_int_time[3] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[3], nummeas, 1);
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[3]);
+ if ((ev = i1pro_dark_measure(p, s->idark_data[3],
+ nummeas, &s->idark_int_time[3], 1)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ }
+#endif /* USE_HIGH_GAIN_MODE */
+
+ i1pro_prepare_idark(p);
+ s->idark_valid = 1;
+ s->iddate = cdate;
+
+ if ((ev = i1pro_interp_dark(p, s->dark_data, s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->want_dcalib = 0;
+ s->ddate = s->iddate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ *calt &= ~(inst_calt_ref_dark
+ | inst_calt_em_dark
+ | inst_calt_trans_dark);
+
+ /* Save the calib to all similar modes */
+ /* We're assuming they have the same int times */
+ a1logd(p->log,5,"Saving adaptive black calib to similar modes\n");
+ for (i = 0; i < i1p_no_modes; i++) {
+ i1pro_state *ss = &m->ms[i];
+ if (ss == s || ss->iddate == s->iddate)
+ continue;
+ if ((ss->emiss || ss->trans) && ss->adaptive && !ss->scan) {
+ ss->idark_valid = s->idark_valid;
+ ss->want_dcalib = s->want_dcalib;
+ ss->iddate = s->iddate;
+ ss->dark_int_time = s->dark_int_time;
+ ss->dark_gain_mode = s->dark_gain_mode;
+#ifdef USE_HIGH_GAIN_MODE
+ for (j = 0; j < (p->itype != instI1Pro2) ? 4 : 2; j++)
+#else
+ for (j = 0; j < 2; j++)
+#endif
+ {
+ ss->idark_int_time[j] = s->idark_int_time[j];
+ for (k = -1; k < m->nraw; k++)
+ ss->idark_data[j][k] = s->idark_data[j][k];
+ }
+ }
+ }
+
+ a1logd(p->log,5,"Done adaptive interpolated black calibration\n");
+
+ /* Test accuracy of dark level interpolation */
+#ifdef TEST_DARK_INTERP
+ {
+ double tinttime;
+ double ref[128], interp[128];
+
+ // fprintf(stderr,"Normal gain offsets:\n");
+ // plot_raw(s->idark_data[0]);
+ // fprintf(stderr,"Normal gain multiplier:\n");
+ // plot_raw(s->idark_data[1]);
+
+#ifdef DUMP_DARKM
+ extern int ddumpdarkm;
+ ddumpdarkm = 1;
+#endif
+ for (tinttime = m->min_int_time; ; tinttime *= 2.0) {
+ if (tinttime >= m->max_int_time)
+ tinttime = m->max_int_time;
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, tinttime);
+ if ((ev = i1pro_dark_measure(p, ref, nummeas, &tinttime, 0)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ i1pro_interp_dark(p, interp, tinttime, 0);
+#ifdef DEBUG
+ fprintf(stderr,"Low gain ref vs. interp dark offset for inttime %f:\n",tinttime);
+ plot_raw2(ref, interp);
+#endif
+ if ((tinttime * 1.1) > m->max_int_time)
+ break;
+ }
+#ifdef DUMP_DARKM
+ ddumpdarkm = 0;
+#endif
+
+#ifdef USE_HIGH_GAIN_MODE
+ if (p->itype != instI1Pro2) { /* Rev E doesn't have high gain mode */
+ // fprintf(stderr,"High gain offsets:\n");
+ // plot_raw(s->idark_data[2]);
+ // fprintf(stderr,"High gain multiplier:\n");
+ // plot_raw(s->idark_data[3]);
+
+ for (tinttime = m->min_int_time; ; tinttime *= 2.0) {
+ if (tinttime >= m->max_int_time)
+ tinttime = m->max_int_time;
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, tinttime);
+ if ((ev = i1pro_dark_measure(p, ref, nummeas, &tinttime, 1)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ i1pro_interp_dark(p, interp, tinttime, 1);
+#ifdef DEBUG
+ fprintf(stderr,"High gain ref vs. interp dark offset for inttime %f:\n",tinttime);
+ plot_raw2(ref, interp);
+#endif
+ if ((tinttime * 1.1) > m->max_int_time)
+ break;
+ }
+ }
+#endif /* USE_HIGH_GAIN_MODE */
+ }
+#endif /* NEVER */
+
+ }
+
+ /* Deal with an emissive/transmisive adaptive black reference */
+ /* when in scan mode. */
+ if ((*calt & (inst_calt_ref_dark
+ | inst_calt_em_dark
+ | inst_calt_trans_dark | inst_calt_ap_flag))
+ && (*calc == inst_calc_man_ref_white /* Any condition conducive to dark calib */
+ || *calc == inst_calc_man_em_dark
+ || *calc == inst_calc_man_am_dark
+ || *calc == inst_calc_man_trans_dark)
+ && ((s->emiss && s->adaptive && s->scan)
+ || (s->trans && s->adaptive && s->scan))) {
+ int j;
+
+ a1logd(p->log,2,"\nDoing emis/trans adapative scan mode black calibration\n");
+
+ /* We know scan is locked to the minimum integration time, */
+ /* so we can measure the dark data at that integration time, */
+ /* but we don't know what gain mode will be used, so measure both, */
+ /* and choose the appropriate one on the fly. */
+
+ s->idark_int_time[0] = s->inttime;
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[0]);
+ a1logd(p->log,2,"\nDoing adaptive scan black calibration, dcaltime %f, idark_int_time[0] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[0], nummeas, s->gainmode);
+ if ((ev = i1pro_dark_measure(p, s->idark_data[0],
+ nummeas, &s->idark_int_time[0], 0)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+
+#ifdef USE_HIGH_GAIN_MODE
+ if (p->itype != instI1Pro2) { /* Rev E doesn't have high gain mode */
+ s->idark_int_time[2] = s->inttime;
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->idark_int_time[2]);
+ a1logd(p->log,2,"Doing adaptive scan black calibration, dcaltime %f, idark_int_time[2] %f, nummeas %d, gainmode %d\n", s->dcaltime, s->idark_int_time[2], nummeas, s->gainmode);
+ if ((ev = i1pro_dark_measure(p, s->idark_data[2],
+ nummeas, &s->idark_int_time[2], 1)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ }
+#endif
+
+ s->idark_valid = 1;
+ s->iddate = cdate;
+
+#ifdef USE_HIGH_GAIN_MODE
+ if (s->gainmode) {
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data[j] = s->idark_data[2][j];
+ } else
+#endif
+ {
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data[j] = s->idark_data[0][j];
+ }
+ s->dark_valid = 1;
+ s->want_dcalib = 0;
+ s->ddate = s->iddate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ *calt &= ~(inst_calt_ref_dark
+ | inst_calt_em_dark
+ | inst_calt_trans_dark);
+
+ a1logd(p->log,2,"Done adaptive scan black calibration\n");
+
+ /* Save the calib to all similar modes */
+ /* We're assuming they have the same int times */
+ a1logd(p->log,5,"Saving adaptive scan black calib to similar modes\n");
+ for (i = 0; i < i1p_no_modes; i++) {
+ i1pro_state *ss = &m->ms[i];
+ if (ss == s || ss->iddate == s->iddate)
+ continue;
+ if ((ss->emiss || ss->trans) && ss->adaptive && s->scan) {
+ ss->idark_valid = s->idark_valid;
+ ss->want_dcalib = s->want_dcalib;
+ ss->iddate = s->iddate;
+ ss->dark_int_time = s->dark_int_time;
+ ss->dark_gain_mode = s->dark_gain_mode;
+#ifdef USE_HIGH_GAIN_MODE
+ for (j = 0; j < (p->itype != instI1Pro2) ? 4 : 2; j += 2)
+#else
+ for (j = 0; j < 2; j += 2)
+#endif
+ {
+ ss->idark_int_time[j] = s->idark_int_time[j];
+ for (k = -1; k < m->nraw; k++)
+ ss->idark_data[j][k] = s->idark_data[j][k];
+ }
+ }
+ }
+ }
+
+ /* If we are doing a white reference calibrate */
+ if ((*calt & (inst_calt_ref_white
+ | inst_calt_trans_vwhite | inst_calt_ap_flag))
+ && ((*calc == inst_calc_man_ref_white && s->reflective)
+ || (*calc == inst_calc_man_trans_white && s->trans))) {
+ double scale;
+
+ a1logd(p->log,2,"\nDoing initial white calibration with current inttime %f, gainmode %d\n",
+ s->inttime, s->gainmode);
+ nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+ ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data, &scale, nummeas,
+ &s->inttime, s->gainmode, s->scan ? 1.0 : s->targoscale, 0);
+ if (ev == I1PRO_RD_SENSORSATURATED) {
+ scale = 0.0; /* Signal it this way */
+ ev = I1PRO_OK;
+ }
+ if (ev != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+
+ /* For non-scan modes, we adjust the integration time to avoid saturation, */
+ /* and to try and match the target optimal sensor value */
+ if (!s->scan) {
+ /* If it's adaptive and not good, or if it's not adaptive and even worse, */
+ /* or if we're using lamp dynamic compensation for reflective scan, */
+ /* change the parameters until the white is optimal. */
+ if ((s->adaptive && (scale < 0.95 || scale > 1.05))
+ || (scale < 0.3 || scale > 2.0)) {
+
+ /* Need to have done adaptive black measure to change inttime/gain params */
+ if (*calc != inst_calc_man_ref_white && !s->idark_valid) {
+ m->mmode = mmode; /* Restore actual mode */
+ return I1PRO_RD_TRANSWHITERANGE;
+ }
+
+ if (scale == 0.0) { /* If sensor was saturated */
+ s->inttime = m->min_int_time;
+ s->gainmode = 0;
+ s->dark_valid = 0;
+ if (!s->emiss)
+ s->cal_valid = 0;
+
+ if (*calc == inst_calc_man_ref_white) {
+ nummeas = i1pro_comp_nummeas(p, s->dadaptime, s->inttime);
+ a1logd(p->log,2,"Doing another black calibration with dadaptime %f, min inttime %f, nummeas %d, gainmode %d\n", s->dadaptime, s->inttime, nummeas, s->gainmode);
+ if ((ev = i1pro_dark_measure(p, s->dark_data,
+ nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+
+ } else if (s->idark_valid) {
+ /* compute interpolated dark refence for chosen inttime & gainmode */
+ a1logd(p->log,2,"Interpolate dark calibration reference\n");
+ if ((ev = i1pro_interp_dark(p, s->dark_data,
+ s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->ddate = s->iddate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ } else {
+ m->mmode = mmode; /* Restore actual mode */
+ return I1PRO_INT_NOINTERPDARK;
+ }
+ a1logd(p->log,2,"Doing another white calibration with min inttime %f, gainmode %d\n",
+ s->inttime,s->gainmode);
+ nummeas = i1pro_comp_nummeas(p, s->wadaptime, s->inttime);
+ if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+ &scale, nummeas, &s->inttime, s->gainmode, s->targoscale, 0))
+ != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ }
+
+ /* Compute a new integration time and gain mode */
+ /* in order to optimise the sensor values. Error if can't get */
+ /* scale we want. */
+ if ((ev = i1pro_optimise_sensor(p, &s->inttime, &s->gainmode,
+ s->inttime, s->gainmode, s->trans, 0, s->targoscale, scale)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ a1logd(p->log,2,"Computed optimal white inttime %f and gainmode %d\n",
+ s->inttime,s->gainmode);
+
+ if (*calc == inst_calc_man_ref_white) {
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+ a1logd(p->log,2,"Doing final black calibration with dcaltime %f, opt inttime %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+ if ((ev = i1pro_dark_measure(p, s->dark_data,
+ nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->ddate = cdate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+
+ } else if (s->idark_valid) {
+ /* compute interpolated dark refence for chosen inttime & gainmode */
+ a1logd(p->log,2,"Interpolate dark calibration reference\n");
+ if ((ev = i1pro_interp_dark(p, s->dark_data,
+ s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->ddate = s->iddate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ } else {
+ m->mmode = mmode; /* Restore actual mode */
+ return I1PRO_INT_NOINTERPDARK;
+ }
+
+ a1logd(p->log,2,"Doing final white calibration with opt int_time %f, gainmode %d\n",
+ s->inttime,s->gainmode);
+ nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+ if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+ &scale, nummeas, &s->inttime, s->gainmode, s->targoscale, ltocmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ }
+
+ /* For scan we take a different approach. We try and use the minimum possible */
+ /* integration time so as to maximize sampling rate, and adjust the gain */
+ /* if necessary. */
+ } else if (s->adaptive) {
+ int j;
+ if (scale == 0.0) { /* If sensor was saturated */
+ a1logd(p->log,3,"Scan illuminant is saturating sensor\n");
+ if (s->gainmode == 0) {
+ m->mmode = mmode; /* Restore actual mode */
+ return I1PRO_RD_SENSORSATURATED; /* Nothing we can do */
+ }
+ a1logd(p->log,3,"Switching to low gain mode\n");
+ s->gainmode = 0;
+ /* Measure white again with low gain */
+ nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+ if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+ &scale, nummeas, &s->inttime, s->gainmode, 1.0, 0)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ } else if (p->itype != instI1Pro2 && s->gainmode == 0 && scale > m->highgain) {
+#ifdef USE_HIGH_GAIN_MODE
+ a1logd(p->log,3,"Scan signal is so low we're switching to high gain mode\n");
+ s->gainmode = 1;
+ /* Measure white again with high gain */
+ nummeas = i1pro_comp_nummeas(p, s->wcaltime, s->inttime);
+ if ((ev = i1pro_whitemeasure(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+ &scale, nummeas, &s->inttime, s->gainmode, 1.0, 0)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+#endif /* USE_HIGH_GAIN_MODE */
+ }
+
+ a1logd(p->log,2,"After scan gain adaption scale = %f\n",scale);
+ if (scale > 6.0) {
+ m->transwarn |= 2;
+ a1logd(p->log,2, "scan white reference is not bright enough by %f\n",scale);
+ }
+
+ if (*calc == inst_calc_man_ref_white) {
+ nummeas = i1pro_comp_nummeas(p, s->dcaltime, s->inttime);
+ a1logd(p->log,2,"Doing final black calibration with dcaltime %f, opt inttime %f, nummeas %d, gainmode %d\n", s->dcaltime, s->inttime, nummeas, s->gainmode);
+ if ((ev = i1pro_dark_measure(p, s->dark_data,
+ nummeas, &s->inttime, s->gainmode)) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->ddate = cdate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+
+ } else if (s->idark_valid) {
+ /* compute interpolated dark refence for chosen inttime & gainmode */
+ a1logd(p->log,2,"Interpolate dark calibration reference\n");
+ if (s->gainmode) {
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data[j] = s->idark_data[2][j];
+ } else {
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data[j] = s->idark_data[0][j];
+ }
+ s->dark_valid = 1;
+ s->ddate = s->iddate;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ } else {
+ m->mmode = mmode; /* Restore actual mode */
+ return I1PRO_INT_NOINTERPDARK;
+ }
+ a1logd(p->log,2,"Doing final white calibration with opt int_time %f, gainmode %d\n",
+ s->inttime,s->gainmode);
+ }
+
+ /* We've settled on the inttime and gain mode to get a good white reference. */
+ if (s->reflective) { /* We read the white reference - check it */
+ /* Check a reflective white measurement, and check that */
+ /* it seems reasonable. Return I1PRO_OK if it is, error if not. */
+ /* (Using cal_factor[] as temp.) */
+ a1logd(p->log,2,"Checking white reference\n");
+ if ((ev = i1pro_check_white_reference1(p, s->cal_factor[0])) != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ /* Compute a calibration factor given the reading of the white reference. */
+ i1pro_compute_white_cal(p, s->cal_factor[0], m->white_ref[0], s->cal_factor[0],
+ s->cal_factor[1], m->white_ref[1], s->cal_factor[1]);
+
+ } else {
+ /* Compute a calibration factor given the reading of the white reference. */
+ m->transwarn |= i1pro_compute_white_cal(p, s->cal_factor[0], NULL, s->cal_factor[0],
+ s->cal_factor[1], NULL, s->cal_factor[1]);
+ }
+ s->cal_valid = 1;
+ s->cfdate = cdate;
+ s->want_calib = 0;
+ *calt &= ~(inst_calt_ref_white
+ | inst_calt_trans_vwhite);
+ }
+
+ /* Deal with a display integration time selection */
+ if ((*calt & (inst_calt_emis_int_time | inst_calt_ap_flag))
+ && *calc == inst_calc_emis_white
+ && (s->emiss && !s->adaptive && !s->scan)) {
+ double scale;
+ double *data;
+ double *tt, tv;
+
+ data = dvectorz(-1, m->nraw-1);
+
+ a1logd(p->log,2,"\nDoing display integration time calibration\n");
+
+ /* Undo any previous swaps */
+ if (s->dispswap == 1) {
+ tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+ } else if (s->dispswap == 2) {
+ tv = s->inttime; s->inttime = s->dark_int_time3; s->dark_int_time3 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data3; s->dark_data3 = tt;
+ }
+ s->dispswap = 0;
+
+ /* Simply measure the full display white, and if it's close to */
+ /* saturation, switch to the alternate display integration time */
+ nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+ ev = i1pro_whitemeasure(p, NULL, NULL, data , &scale, nummeas,
+ &s->inttime, s->gainmode, s->targoscale, 0);
+ /* Switch to the alternate if things are too bright */
+ /* We do this simply by swapping the alternate values in. */
+ if (ev == I1PRO_RD_SENSORSATURATED || scale < 1.0) {
+ a1logd(p->log,2,"Switching to alternate display integration time %f seconds\n",s->dark_int_time2);
+ tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+ s->dispswap = 1;
+
+ /* Do another measurement of the full display white, and if it's close to */
+ /* saturation, switch to the 3rd alternate display integration time */
+ nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+ ev = i1pro_whitemeasure(p, NULL, NULL, data , &scale, nummeas,
+ &s->inttime, s->gainmode, s->targoscale, 0);
+ /* Switch to the 3rd alternate if things are too bright */
+ /* We do this simply by swapping the alternate values in. */
+ if (ev == I1PRO_RD_SENSORSATURATED || scale < 1.0) {
+ a1logd(p->log,2,"Switching to 3rd alternate display integration time %f seconds\n",s->dark_int_time3);
+ /* Undo previous swap */
+ tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+ /* swap in 2nd alternate */
+ tv = s->inttime; s->inttime = s->dark_int_time3; s->dark_int_time3 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data3; s->dark_data3 = tt;
+ s->dispswap = 2;
+ }
+ }
+ free_dvector(data, -1, m->nraw-1);
+ if (ev != I1PRO_OK) {
+ m->mmode = mmode; /* Restore actual mode */
+ return ev;
+ }
+ s->done_dintsel = 1;
+ s->diseldate = cdate;
+ *calt &= ~inst_calt_emis_int_time;
+
+ a1logd(p->log,5,"Done display integration time calibration\n");
+ }
+
+ } /* Look at next mode */
+ m->mmode = mmode; /* Restore actual mode */
+
+ /* Make sure there's the right condition for any remaining calibrations */
+ if (*calt & inst_calt_wavelength) { /* Wavelength calibration */
+ if (cs->emiss && cs->ambient) {
+ id[0] = '\000';
+ if (*calc != inst_calc_man_am_dark) {
+ *calc = inst_calc_man_am_dark; /* Calibrate using ambient adapter */
+ return I1PRO_CAL_SETUP;
+ }
+ } else {
+ sprintf(id, "Serial no. %d",m->serno);
+ if (*calc != inst_calc_man_ref_white) {
+ *calc = inst_calc_man_ref_white; /* Calibrate using white tile */
+ return I1PRO_CAL_SETUP;
+ }
+ }
+ } else if (*calt & (inst_calt_ref_dark | inst_calt_ref_white)) {
+ sprintf(id, "Serial no. %d",m->serno);
+ if (*calc != inst_calc_man_ref_white) {
+ *calc = inst_calc_man_ref_white; /* Calibrate using white tile */
+ return I1PRO_CAL_SETUP;
+ }
+ } else if (*calt & inst_calt_em_dark) { /* Emissive Dark calib */
+ id[0] = '\000';
+ if (*calc != inst_calc_man_em_dark) {
+ *calc = inst_calc_man_em_dark; /* Any sort of dark reference */
+ return I1PRO_CAL_SETUP;
+ }
+ } else if (*calt & inst_calt_trans_dark) { /* Transmissvice dark */
+ id[0] = '\000';
+ if (*calc != inst_calc_man_trans_dark) {
+ *calc = inst_calc_man_trans_dark;
+ return I1PRO_CAL_SETUP;
+ }
+ } else if (*calt & inst_calt_trans_vwhite) {/* Transmissvice white for emulated transmission */
+ id[0] = '\000';
+ if (*calc != inst_calc_man_trans_white) {
+ *calc = inst_calc_man_trans_white;
+ return I1PRO_CAL_SETUP;
+ }
+ } else if (*calt & inst_calt_emis_int_time) {
+ id[0] = '\000';
+ if (*calc != inst_calc_emis_white) {
+ *calc = inst_calc_emis_white;
+ return I1PRO_CAL_SETUP;
+ }
+ }
+
+ /* Go around again if we've still got calibrations to do */
+ if (*calt & inst_calt_all_mask) {
+ return I1PRO_CAL_SETUP;
+ }
+
+ /* We must be done */
+
+ /* Update and write the EEProm log if the is a refspot calibration */
+ if (cs->reflective && !cs->scan && cs->dark_valid && cs->cal_valid) {
+ m->calcount = m->rpcount;
+ m->caldate = cdate;
+ if ((ev = i1pro_update_log(p)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_update_log: Updating the cal and log parameters"
+ " to EEProm failed\n");
+ }
+ }
+
+#ifdef ENABLE_NONVCAL
+ /* Save the calibration to a file */
+ i1pro_save_calibration(p);
+#endif
+
+ if (m->transwarn) {
+ *calc = inst_calc_message;
+ if (m->transwarn & 2)
+ strcpy(id, "Warning: Transmission light source is too low for accuracy!");
+ else
+ strcpy(id, "Warning: Transmission light source is low at some wavelengths!");
+ m->transwarn = 0;
+ }
+
+ a1logd(p->log,2,"Finished cal with dark_valid = %d, cal_valid = %d\n",cs->dark_valid, cs->cal_valid);
+
+ return I1PRO_OK;
+}
+
+/* Interpret an icoms error into a I1PRO error */
+int icoms2i1pro_err(int se) {
+ if (se != ICOM_OK)
+ return I1PRO_COMS_FAIL;
+ return I1PRO_OK;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Measure a patch or strip in the current mode. */
+/* To try and speed up the reaction time between */
+/* triggering a scan measurement and being able to */
+/* start moving the instrument, we pre-allocate */
+/* all the buffers and arrays, and pospone processing */
+/* until after the scan is complete. */
+i1pro_code i1pro_imp_measure(
+ i1pro *p,
+ ipatch *vals, /* Pointer to array of instrument patch value */
+ int nvals, /* Number of values */
+ instClamping clamp /* Clamp XYZ/Lab to be +ve */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ unsigned char *buf = NULL; /* Raw USB reading buffer for reflection dark cal */
+ unsigned int bsize;
+ unsigned char *mbuf = NULL; /* Raw USB reading buffer for measurement */
+ unsigned int mbsize;
+ int nummeas = 0, maxnummeas = 0;
+ int nmeasuered = 0; /* Number actually measured */
+ double **specrd = NULL; /* Cooked spectral patch values */
+ double duration = 0.0; /* Possible flash duration value */
+ int user_trig = 0;
+
+ a1logd(p->log,2,"i1pro_imp_measure: Taking %d measurments in %s%s%s%s%s%s mode called\n", nvals,
+ s->emiss ? "Emission" : s->trans ? "Trans" : "Refl",
+ s->emiss && s->ambient ? " Ambient" : "",
+ s->scan ? " Scan" : "",
+ s->flash ? " Flash" : "",
+ s->adaptive ? " Adaptive" : "",
+ m->uv_en ? " UV" : "");
+
+
+ if ((s->emiss && s->adaptive && !s->idark_valid)
+ || ((!s->emiss || !s->adaptive) && !s->dark_valid)
+ || !s->cal_valid) {
+ a1logd(p->log,3,"emis %d, adaptive %d, idark_valid %d\n",s->emiss,s->adaptive,s->idark_valid);
+ a1logd(p->log,3,"dark_valid %d, cal_valid %d\n",s->dark_valid,s->cal_valid);
+ a1logd(p->log,3,"i1pro_imp_measure need calibration\n");
+ return I1PRO_RD_NEEDS_CAL;
+ }
+
+ if (nvals <= 0
+ || (!s->scan && nvals > 1)) {
+ a1logd(p->log,2,"i1pro_imp_measure wrong number of patches\n");
+ return I1PRO_INT_WRONGPATCHES;
+ }
+
+ /* Notional number of measurements, befor adaptive and not counting scan */
+ nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+
+ /* Allocate buf for pre-measurement dark calibration */
+ if (s->reflective) {
+ bsize = m->nsen * 2 * nummeas;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (5)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+ }
+
+ /* Allocate buffer for measurement */
+ maxnummeas = i1pro_comp_nummeas(p, s->maxscantime, s->inttime);
+ if (maxnummeas < nummeas)
+ maxnummeas = nummeas;
+ mbsize = m->nsen * 2 * maxnummeas;
+ if ((mbuf = (unsigned char *)malloc(sizeof(unsigned char) * mbsize)) == NULL) {
+ if (buf != NULL)
+ free(buf);
+ a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (6)\n",mbsize);
+ return I1PRO_INT_MALLOC;
+ }
+ specrd = dmatrix(0, nvals-1, 0, m->nwav[m->highres]-1);
+
+ if (m->trig == inst_opt_trig_user_switch) {
+ m->hide_switch = 1; /* Supress switch events */
+
+#ifdef USE_THREAD
+ {
+ int currcount = m->switch_count; /* Variable set by thread */
+ while (currcount == m->switch_count) {
+ inst_code rc;
+ int cerr;
+
+ /* Don't trigger on user key if scan, only trigger */
+ /* on instrument switch */
+ if (p->uicallback != NULL
+ && (rc = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+ if (rc == inst_user_abort) {
+ ev = I1PRO_USER_ABORT;
+ break; /* Abort */
+ }
+ if (!s->scan && rc == inst_user_trig) {
+ ev = I1PRO_USER_TRIG;
+ user_trig = 1;
+ break; /* Trigger */
+ }
+ }
+ msec_sleep(100);
+ }
+ }
+#else
+ /* Throw one away in case the switch was pressed prematurely */
+ i1pro_waitfor_switch_th(p, 0.01);
+
+ for (;;) {
+ inst_code rc;
+ int cerr;
+
+ if ((ev = i1pro_waitfor_switch_th(p, 0.1)) != I1PRO_OK
+ && ev != I1PRO_INT_BUTTONTIMEOUT)
+ break; /* Error */
+
+ if (ev == I1PRO_OK)
+ break; /* switch triggered */
+
+ /* Don't trigger on user key if scan, only trigger */
+ /* on instrument switch */
+ if (p->uicallback != NULL
+ && (rc = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+ if (rc == inst_user_abort) {
+ ev = I1PRO_USER_ABORT;
+ break; /* Abort */
+ }
+ if (!s->scan && rc == inst_user_trig) {
+ ev = I1PRO_USER_TRIG;
+ user_trig = 1;
+ break; /* Trigger */
+ }
+ }
+ }
+#endif
+ a1logd(p->log,3,"############# triggered ##############\n");
+ if (p->uicallback) /* Notify of trigger */
+ p->uicallback(p->uic_cntx, inst_triggered);
+
+ m->hide_switch = 0; /* Enable switch events again */
+
+ } else if (m->trig == inst_opt_trig_user) {
+ if (p->uicallback == NULL) {
+ a1logd(p->log, 1, "hcfr: inst_opt_trig_user but no uicallback function set!\n");
+ ev = I1PRO_UNSUPPORTED;
+
+ } else {
+
+ for (;;) {
+ inst_code rc;
+ if ((rc = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+ if (rc == inst_user_abort) {
+ ev = I1PRO_USER_ABORT; /* Abort */
+ break;
+ }
+ if (rc == inst_user_trig) {
+ ev = I1PRO_USER_TRIG;
+ user_trig = 1;
+ break; /* Trigger */
+ }
+ }
+ msec_sleep(200);
+ }
+ }
+ a1logd(p->log,3,"############# triggered ##############\n");
+ if (p->uicallback) /* Notify of trigger */
+ p->uicallback(p->uic_cntx, inst_triggered);
+
+ /* Progromatic Trigger */
+ } else {
+ /* Check for abort */
+ if (p->uicallback != NULL
+ && (ev = p->uicallback(p->uic_cntx, inst_armed)) == inst_user_abort)
+ ev = I1PRO_USER_ABORT; /* Abort */
+ }
+
+ if (ev != I1PRO_OK && ev != I1PRO_USER_TRIG) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(mbuf);
+ if (buf != NULL)
+ free(buf);
+ a1logd(p->log,2,"i1pro_imp_measure user aborted, terminated, command, or failure\n");
+ return ev; /* User abort, term, command or failure */
+ }
+
+ if (s->emiss && !s->scan && s->adaptive) {
+ int saturated = 0;
+ double optscale = 1.0;
+ s->inttime = 0.25;
+ s->gainmode = 0;
+ s->dark_valid = 0;
+
+ a1logd(p->log,2,"Trial measure emission with inttime %f, gainmode %d\n",s->inttime,s->gainmode);
+
+ /* Take a trial measurement reading using the current mode. */
+ /* Used to determine if sensor is saturated, or not optimal */
+// nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+ nummeas = 1;
+ if ((ev = i1pro_trialmeasure(p, &saturated, &optscale, nummeas, &s->inttime, s->gainmode,
+ s->targoscale)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure trial measure failed\n");
+ return ev;
+ }
+
+ if (saturated) {
+ s->inttime = m->min_int_time;
+
+ a1logd(p->log,2,"2nd trial measure emission with inttime %f, gainmode %d\n",
+ s->inttime,s->gainmode);
+ /* Take a trial measurement reading using the current mode. */
+ /* Used to determine if sensor is saturated, or not optimal */
+ nummeas = i1pro_comp_nummeas(p, 0.25, s->inttime);
+ if ((ev = i1pro_trialmeasure(p, &saturated, &optscale, nummeas, &s->inttime,
+ s->gainmode, s->targoscale)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure trial measure failed\n");
+ return ev;
+ }
+ }
+
+ a1logd(p->log,2,"Compute optimal integration time\n");
+ /* For adaptive mode, compute a new integration time and gain mode */
+ /* in order to optimise the sensor values. */
+ if ((ev = i1pro_optimise_sensor(p, &s->inttime, &s->gainmode,
+ s->inttime, s->gainmode, 1, 1, s->targoscale, optscale)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure optimise sensor failed\n");
+ return ev;
+ }
+ a1logd(p->log,2,"Computed optimal emiss inttime %f and gainmode %d\n",s->inttime,s->gainmode);
+
+ a1logd(p->log,2,"Interpolate dark calibration reference\n");
+ if ((ev = i1pro_interp_dark(p, s->dark_data, s->inttime, s->gainmode)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure interplate dark ref failed\n");
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+
+ /* Recompute number of measurements and realloc measurement buffer */
+ free(mbuf);
+ nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+ maxnummeas = i1pro_comp_nummeas(p, s->maxscantime, s->inttime);
+ if (maxnummeas < nummeas)
+ maxnummeas = nummeas;
+ mbsize = m->nsen * 2 * maxnummeas;
+ if ((mbuf = (unsigned char *)malloc(sizeof(unsigned char) * mbsize)) == NULL) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (7)\n",mbsize);
+ return I1PRO_INT_MALLOC;
+ }
+
+ } else if (s->reflective) {
+
+ DISDPLOT
+
+ a1logd(p->log,2,"Doing on the fly black calibration_1 with nummeas %d int_time %f, gainmode %d\n",
+ nummeas, s->inttime, s->gainmode);
+
+ if ((ev = i1pro_dark_measure_1(p, nummeas, &s->inttime, s->gainmode, buf, bsize))
+ != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(buf);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure dak measure 1 failed\n");
+ return ev;
+ }
+
+ ENDPLOT
+ }
+ /* Take a measurement reading using the current mode. */
+ /* Converts to completely processed output readings. */
+
+ a1logd(p->log,2,"Do main measurement reading\n");
+
+ /* Indicate to the user that they can now scan the instrument, */
+ /* after a little delay that allows for the instrument reaction time. */
+ if (s->scan) {
+ /* 500msec delay, 1KHz for 200 msec */
+ msec_beep(200 + (int)(s->lamptime * 1000.0 + 0.5), 1000, 200);
+ }
+
+ /* Retry loop for certaing cases */
+ for (;;) {
+
+ /* Trigger measure and gather raw readings */
+ if ((ev = i1pro_read_patches_1(p, nummeas, maxnummeas, &s->inttime, s->gainmode,
+ &nmeasuered, mbuf, mbsize)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ if (buf != NULL)
+ free(buf);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_read_patches_1\n");
+ return ev;
+ }
+
+ /* Complete reflective black reference measurement */
+ if (s->reflective) {
+ a1logd(p->log,3,"Calling black calibration_2 calc with nummeas %d, inttime %f, gainmode %d\n", nummeas, s->inttime,s->gainmode);
+ if ((ev = i1pro_dark_measure_2(p, s->dark_data,
+ nummeas, s->inttime, s->gainmode, buf, bsize)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(buf);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_dark_measure_2\n");
+ return ev;
+ }
+ s->dark_valid = 1;
+ s->dark_int_time = s->inttime;
+ s->dark_gain_mode = s->gainmode;
+ free(buf);
+ }
+
+ /* Process the raw measurement readings into final spectral readings */
+ ev = i1pro_read_patches_2(p, &duration, specrd, nvals, s->inttime, s->gainmode,
+ nmeasuered, mbuf, mbsize);
+ /* Special case display mode read. If the sensor is saturated, and */
+ /* we haven't already done so, switch to the alternate integration time */
+ /* and try again. */
+ if (s->emiss && !s->scan && !s->adaptive
+ && ev == I1PRO_RD_SENSORSATURATED
+ && s->dispswap < 2) {
+ double *tt, tv;
+
+ if (s->dispswap == 0) {
+ a1logd(p->log,2,"Switching to alternate display integration time %f seconds\n",s->dark_int_time2);
+ tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+ s->dispswap = 1;
+ } else if (s->dispswap == 1) {
+ a1logd(p->log,2,"Switching to 2nd alternate display integration time %f seconds\n",s->dark_int_time3);
+ /* Undo first swap */
+ tv = s->inttime; s->inttime = s->dark_int_time2; s->dark_int_time2 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data2; s->dark_data2 = tt;
+ /* Do 2nd swap */
+ tv = s->inttime; s->inttime = s->dark_int_time3; s->dark_int_time3 = tv;
+ tt = s->dark_data; s->dark_data = s->dark_data3; s->dark_data3 = tt;
+ s->dispswap = 2;
+ }
+ /* Recompute number of measurements and realloc measurement buffer */
+ free(mbuf);
+ nummeas = i1pro_comp_nummeas(p, s->wreadtime, s->inttime);
+ maxnummeas = i1pro_comp_nummeas(p, s->maxscantime, s->inttime);
+ if (maxnummeas < nummeas)
+ maxnummeas = nummeas;
+ mbsize = m->nsen * 2 * maxnummeas;
+ if ((mbuf = (unsigned char *)malloc(sizeof(unsigned char) * mbsize)) == NULL) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ a1logd(p->log,1,"i1pro_imp_measure malloc %d bytes failed (7)\n",mbsize);
+ return I1PRO_INT_MALLOC;
+ }
+ continue; /* Do the measurement again */
+ }
+
+ if (ev != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ free(mbuf);
+ a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_read_patches_2\n");
+ return ev;
+ }
+ break; /* Don't repeat */
+ }
+ free(mbuf);
+
+ /* Transfer spectral and convert to XYZ */
+ if ((ev = i1pro_conv2XYZ(p, vals, nvals, specrd, clamp)) != I1PRO_OK) {
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+ a1logd(p->log,2,"i1pro_imp_measure failed at i1pro_conv2XYZ\n");
+ return ev;
+ }
+ free_dmatrix(specrd, 0, nvals-1, 0, m->nwav[m->highres]-1);
+
+ if (nvals > 0)
+ vals[0].duration = duration; /* Possible flash duration */
+
+ /* Update log counters */
+ if (s->reflective) {
+ if (s->scan)
+ m->acount++;
+ else {
+ m->rpinttime = s->inttime;
+ m->rpcount++;
+ }
+ }
+
+ a1logd(p->log,3,"i1pro_imp_measure sucessful return\n");
+ if (user_trig)
+ return I1PRO_USER_TRIG;
+ return ev;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/*
+
+ Determining the refresh rate for a refresh type display.
+
+ This is easy when the max sample rate of the i1 is above
+ the nyquist of the display, and will always be the case
+ for the range we are prepared to measure (up to 100Hz)
+ when using an Rev B, D or E, but is a problem for the
+ rev A and ColorMunki, which can only sample at 113Hz.
+
+ We work around this problem by detecting when
+ we are measuring an alias of the refresh rate, and
+ average the aliasing corrected measurements.
+
+ If there is no aparent refresh, or the refresh rate is not determinable,
+ return a period of 0.0 and inst_ok;
+*/
+
+i1pro_code i1pro_measure_rgb(i1pro *p, double *inttime, double *rgb);
+
+#ifndef PSRAND32L
+# define PSRAND32L(S) ((S) * 1664525L + 1013904223L)
+#endif
+#undef FREQ_SLOW_PRECISE /* [und] Interpolate then autocorrelate, else autc & filter */
+#define NFSAMPS 80 /* Number of samples to read */
+#define NFMXTIME 6.0 /* Maximum time to take (2000 == 6) */
+#define PBPMS 20 /* bins per msec */
+#define PERMIN ((1000 * PBPMS)/40) /* 40 Hz */
+#define PERMAX ((1000 * PBPMS)/4) /* 4 Hz*/
+#define NPER (PERMAX - PERMIN + 1)
+#define PWIDTH (8 * PBPMS) /* 8 msec bin spread to look for peak in */
+#define MAXPKS 20 /* Number of peaks to find */
+#define TRIES 8 /* Number of different sample rates to try */
+
+i1pro_code i1pro_imp_meas_refrate(
+ i1pro *p,
+ double *ref_rate
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ int i, j, k, mm;
+ double **multimeas; /* Spectral measurements */
+ int nummeas;
+ double rgbw[3] = { 610.0, 520.0, 460.0 };
+ double ucalf = 1.0; /* usec_time calibration factor */
+ double inttime;
+ static unsigned int randn = 0x12345678;
+ struct {
+ double sec;
+ double rgb[3];
+ } samp[NFSAMPS * 2];
+ int nfsamps; /* Actual samples read */
+ double minv[3]; /* Minimum reading */
+ double maxv[3]; /* Maximum reading */
+ double maxt; /* Time range */
+#ifdef FREQ_SLOW_PRECISE
+ int nbins;
+ double *bins[3]; /* PBPMS sample bins */
+#else
+ double tcorr[NPER]; /* Temp for initial autocorrelation */
+ int ntcorr[NPER]; /* Number accumulated */
+#endif
+ double corr[NPER]; /* Filtered correlation for each period value */
+ double mincv, maxcv; /* Max and min correlation values */
+ double crange; /* Correlation range */
+ double peaks[MAXPKS]; /* Peak wavelength */
+ double peakh[MAXPKS]; /* Peak heighheight */
+ int npeaks; /* Number of peaks */
+ double pval; /* Period value */
+ double rfreq[TRIES]; /* Computed refresh frequency for each try */
+ double rsamp[TRIES]; /* Sampling rate used to measure frequency */
+ int tix = 0; /* try index */
+
+ a1logd(p->log,2,"i1pro_imp_meas_refrate called\n");
+
+ if (!s->emiss) {
+ a1logd(p->log,2,"i1pro_imp_meas_refrate not in emissive mode\n");
+ return I1PRO_UNSUPPORTED;
+ }
+
+ for (mm = 0; mm < TRIES; mm++) {
+ rfreq[mm] = 0.0;
+ npeaks = 0; /* Number of peaks */
+ nummeas = NFSAMPS;
+ multimeas = dmatrix(0, nummeas-1, -1, m->nwav[m->highres]-1);
+
+ if (mm == 0)
+ inttime = m->min_int_time;
+ else {
+ double rval, dmm;
+ randn = PSRAND32L(randn);
+ rval = (double)randn/4294967295.0;
+ dmm = ((double)mm + rval - 0.5)/(TRIES - 0.5);
+ inttime = m->min_int_time * (1.0 + dmm * 0.80);
+ }
+
+ if ((ev = i1pro_read_patches_all(p, multimeas, nummeas, &inttime, 0)) != inst_ok) {
+ free_dmatrix(multimeas, 0, nummeas-1, 0, m->nwav[m->highres]-1);
+ return ev;
+ }
+
+ rsamp[tix] = 1.0/inttime;
+
+ /* Convert the samples to RGB */
+ for (i = 0; i < nummeas && i < NFSAMPS; i++) {
+ samp[i].sec = i * inttime;
+ samp[i].rgb[0] = samp[i].rgb[1] = samp[i].rgb[2] = 0.0;
+ for (j = 0; j < m->nwav[m->highres]; j++) {
+ double wl = XSPECT_WL(m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], j);
+
+//printf("~1 multimeas %d %d = %f\n",i, j, multimeas[i][j]);
+ for (k = 0; k < 3; k++) {
+ double tt = (double)(wl - rgbw[k]);
+ tt = (40.0 - fabs(tt))/40.0;
+ if (tt < 0.0)
+ tt = 0.0;
+ samp[i].rgb[k] += tt * multimeas[i][j];
+ }
+ }
+ }
+ nfsamps = i;
+
+ a1logd(p->log, 3, "i1pro_measure_refresh: Read %d samples for refresh calibration\n",nfsamps);
+
+#ifdef NEVER
+ /* Plot the raw sensor values */
+ {
+ double xx[NFSAMPS];
+ double y1[NFSAMPS];
+ double y2[NFSAMPS];
+ double y3[NFSAMPS];
+
+ for (i = 0; i < nfsamps; i++) {
+ xx[i] = samp[i].sec;
+ y1[i] = samp[i].rgb[0];
+ y2[i] = samp[i].rgb[1];
+ y3[i] = samp[i].rgb[2];
+// printf("%d: %f -> %f\n",i,samp[i].sec, samp[i].rgb[0]);
+ }
+ printf("Fast scan sensor values and time (sec)\n");
+ do_plot6(xx, y1, y2, y3, NULL, NULL, NULL, nfsamps);
+ }
+#endif
+
+ /* Locate the smallest values and maximum time */
+ maxt = -1e6;
+ minv[0] = minv[1] = minv[2] = 1e20;
+ maxv[0] = maxv[1] = maxv[2] = -11e20;
+ for (i = nfsamps-1; i >= 0; i--) {
+ if (samp[i].sec > maxt)
+ maxt = samp[i].sec;
+ for (j = 0; j < 3; j++) {
+ if (samp[i].rgb[j] < minv[j])
+ minv[j] = samp[i].rgb[j];
+ if (samp[i].rgb[j] > maxv[j])
+ maxv[j] = samp[i].rgb[j];
+ }
+ }
+ /* Re-zero the sample times, and normalise the readings */
+ for (i = nfsamps-1; i >= 0; i--) {
+ samp[i].sec -= samp[0].sec;
+ samp[i].sec *= ucalf;
+ if (samp[i].sec > maxt)
+ maxt = samp[i].sec;
+ for (j = 0; j < 3; j++) {
+ samp[i].rgb[j] -= minv[j];
+ }
+ }
+
+#ifdef FREQ_SLOW_PRECISE /* Interp then autocorrelate */
+
+ /* Create PBPMS bins and interpolate readings into them */
+ nbins = 1 + (int)(maxt * 1000.0 * PBPMS + 0.5);
+ for (j = 0; j < 3; j++) {
+ if ((bins[j] = (double *)calloc(sizeof(double), nbins)) == NULL) {
+ a1loge(p->log, inst_internal_error, "i1pro_measure_refresh: malloc failed\n");
+ return I1PRO_INT_MALLOC;
+ }
+ }
+
+ /* Do the interpolation */
+ for (k = 0; k < (nfsamps-1); k++) {
+ int sbin, ebin;
+ sbin = (int)(samp[k].sec * 1000.0 * PBPMS + 0.5);
+ ebin = (int)(samp[k+1].sec * 1000.0 * PBPMS + 0.5);
+ for (i = sbin; i <= ebin; i++) {
+ double bl;
+#if defined(__APPLE__) && defined(__POWERPC__)
+ gcc_bug_fix(i);
+#endif
+ bl = (i - sbin)/(double)(ebin - sbin); /* 0.0 to 1.0 */
+ for (j = 0; j < 3; j++) {
+ bins[j][i] = (1.0 - bl) * samp[k].rgb[j] + bl * samp[k+1].rgb[j];
+ }
+ }
+ }
+
+#ifdef NEVER
+
+ /* Plot interpolated values */
+ {
+ double *xx;
+ double *y1;
+ double *y2;
+ double *y3;
+
+ xx = malloc(sizeof(double) * nbins);
+ y1 = malloc(sizeof(double) * nbins);
+ y2 = malloc(sizeof(double) * nbins);
+ y3 = malloc(sizeof(double) * nbins);
+
+ if (xx == NULL || y1 == NULL || y2 == NULL || y3 == NULL) {
+ a1loge(p->log, inst_internal_error, "i1pro_measure_refresh: malloc failed\n");
+ for (j = 0; j < 3; j++)
+ free(bins[j]);
+ return I1PRO_INT_MALLOC;
+ }
+ for (i = 0; i < nbins; i++) {
+ xx[i] = i / (double)PBPMS; /* msec */
+ y1[i] = bins[0][i];
+ y2[i] = bins[1][i];
+ y3[i] = bins[2][i];
+ }
+ printf("Interpolated fast scan sensor values and time (msec) for inttime %f\n",inttime);
+ do_plot6(xx, y1, y2, y3, NULL, NULL, NULL, nbins);
+
+ free(xx);
+ free(y1);
+ free(y2);
+ free(y3);
+ }
+#endif /* PLOT_REFRESH */
+
+ /* Compute auto-correlation at 1/PBPMS msec intervals */
+ /* from 25 msec (40Hz) to 100msec (10 Hz) */
+ mincv = 1e48, maxcv = -1e48;
+ for (i = 0; i < NPER; i++) {
+ int poff = PERMIN + i; /* Offset to corresponding sample */
+
+ corr[i] = 0;
+ for (k = 0; (k + poff) < nbins; k++) {
+ corr[i] += bins[0][k] * bins[0][k + poff]
+ + bins[1][k] * bins[1][k + poff]
+ + bins[2][k] * bins[2][k + poff];
+ }
+ corr[i] /= (double)k; /* Normalize */
+
+ if (corr[i] > maxcv)
+ maxcv = corr[i];
+ if (corr[i] < mincv)
+ mincv = corr[i];
+ }
+ /* Free the bins */
+ for (j = 0; j < 3; j++)
+ free(bins[j]);
+
+#else /* !FREQ_SLOW_PRECISE Fast - autocorrellate then filter */
+
+ /* Upsample by a factor of 2 */
+ for (i = nfsamps-1; i >= 0; i--) {
+ j = 2 * i;
+ samp[j].sec = samp[i].sec;
+ samp[j].rgb[0] = samp[i].rgb[0];
+ samp[j].rgb[1] = samp[i].rgb[1];
+ samp[j].rgb[2] = samp[i].rgb[2];
+ if (i > 0) {
+ j--;
+ samp[j].sec = 0.5 * (samp[i].sec + samp[i-1].sec);
+ samp[j].rgb[0] = 0.5 * (samp[i].rgb[0] + samp[i-1].rgb[0]);
+ samp[j].rgb[1] = 0.5 * (samp[i].rgb[1] + samp[i-1].rgb[1]);
+ samp[j].rgb[2] = 0.5 * (samp[i].rgb[2] + samp[i-1].rgb[2]);
+ }
+ }
+ nfsamps = 2 * nfsamps - 1;
+
+ /* Do point by point correllation of samples */
+ for (i = 0; i < NPER; i++) {
+ tcorr[i] = 0.0;
+ ntcorr[i] = 0;
+ }
+
+ for (j = 0; j < (nfsamps-1); j++) {
+
+ for (k = j+1; k < nfsamps; k++) {
+ double del, cor;
+ int bix;
+
+ del = samp[k].sec - samp[j].sec;
+ bix = (int)(del * 1000.0 * PBPMS + 0.5);
+ if (bix < PERMIN)
+ continue;
+ if (bix > PERMAX)
+ break;
+ bix -= PERMIN;
+
+ cor = samp[j].rgb[0] * samp[k].rgb[0]
+ + samp[j].rgb[1] * samp[k].rgb[1]
+ + samp[j].rgb[2] * samp[k].rgb[2];
+
+//printf("~1 j %d k %d, del %f bix %d cor %f\n",j,k,del,bix,cor);
+ tcorr[bix] += cor;
+ ntcorr[bix]++;
+ }
+ }
+ /* Divide out count and linearly interpolate */
+ j = 0;
+ for (i = 0; i < NPER; i++) {
+ if (ntcorr[i] > 0) {
+ tcorr[i] /= ntcorr[i];
+ if ((i - j) > 1) {
+ if (j == 0) {
+ for (k = j; k < i; k++)
+ tcorr[k] = tcorr[i];
+
+ } else { /* Linearly interpolate from last value */
+ double ww = (double)i-j;
+ for (k = j+1; k < i; k++) {
+ double bl = (k-j)/ww;
+ tcorr[k] = (1.0 - bl) * tcorr[j] + bl * tcorr[i];
+ }
+ }
+ }
+ j = i;
+ }
+ }
+ if (j < (NPER-1)) {
+ for (k = j+1; k < NPER; k++) {
+ tcorr[k] = tcorr[j];
+ }
+ }
+
+#ifdef PLOT_REFRESH
+ /* Plot unfiltered auto correlation */
+ {
+ double xx[NPER];
+ double y1[NPER];
+
+ for (i = 0; i < NPER; i++) {
+ xx[i] = (i + PERMIN) / (double)PBPMS; /* msec */
+ y1[i] = tcorr[i];
+ }
+ printf("Unfiltered auto correlation (msec)\n");
+ do_plot6(xx, y1, NULL, NULL, NULL, NULL, NULL, NPER);
+ }
+#endif /* PLOT_REFRESH */
+
+ /* Apply a gausian filter */
+#define FWIDTH 100
+ {
+ double gaus_[2 * FWIDTH * PBPMS + 1];
+ double *gaus = &gaus_[FWIDTH * PBPMS];
+ double bb = 1.0/pow(2, 5.0);
+ double fw = inttime * 1000.0;
+ int ifw;
+
+//printf("~1 sc = %f = %f msec\n",1.0/inttime, fw);
+//printf("~1 fw = %f, ifw = %d\n",fw,ifw);
+
+ fw *= 0.9;
+ ifw = (int)ceil(fw * PBPMS);
+ if (ifw > FWIDTH * PBPMS)
+ error("i1pro: Not enough space for lanczos 2 filter");
+ for (j = -ifw; j <= ifw; j++) {
+ double x, y;
+ x = j/(PBPMS * fw);
+ if (fabs(x) > 1.0)
+ y = 0.0;
+ else
+ y = 1.0/pow(2, 5.0 * x * x) - bb;
+ gaus[j] = y;
+//printf("~1 gaus[%d] = %f\n",j,y);
+ }
+
+ for (i = 0; i < NPER; i++) {
+ double sum = 0.0;
+ double wght = 0.0;
+
+ for (j = -ifw; j <= ifw; j++) {
+ double w;
+ int ix = i + j;
+ if (ix < 0)
+ ix = -ix;
+ if (ix > (NPER-1))
+ ix = 2 * NPER-1 - ix;
+ w = gaus[j];
+ sum += w * tcorr[ix];
+ wght += w;
+ }
+//printf("~1 corr[%d] wgt = %f\n",i,wght);
+ corr[i] = sum / wght;
+ }
+ }
+
+ /* Compute min & max */
+ mincv = 1e48, maxcv = -1e48;
+ for (i = 0; i < NPER; i++) {
+ if (corr[i] > maxcv)
+ maxcv = corr[i];
+ if (corr[i] < mincv)
+ mincv = corr[i];
+ }
+
+#endif /* !FREQ_SLOW_PRECISE Fast - autocorrellate then filter */
+
+ crange = maxcv - mincv;
+ a1logd(p->log,3,"Correlation value range %f - %f = %f = %f%%\n",mincv, maxcv,crange, 100.0 * (maxcv-mincv)/maxcv);
+
+#ifdef PLOT_REFRESH
+ /* Plot this measuremnts auto correlation */
+ {
+ double xx[NPER];
+ double y1[NPER];
+
+ for (i = 0; i < NPER; i++) {
+ xx[i] = (i + PERMIN) / (double)PBPMS; /* msec */
+ y1[i] = corr[i];
+ }
+ printf("Auto correlation (msec)\n");
+ do_plot6(xx, y1, NULL, NULL, NULL, NULL, NULL, NPER);
+ }
+#endif /* PLOT_REFRESH */
+
+#define PFDB 4 // normally 4
+ /* If there is sufficient level and distict correlations */
+ if (crange/maxcv >= 0.1) {
+
+ a1logd(p->log,PFDB,"Searching for peaks\n");
+
+ /* Locate all the peaks starting at the longest correllation */
+ for (i = (NPER-1-PWIDTH); i >= 0 && npeaks < MAXPKS; i--) {
+ double v1, v2, v3;
+ v1 = corr[i];
+ v2 = corr[i + PWIDTH/2]; /* Peak */
+ v3 = corr[i + PWIDTH];
+
+ if (fabs(v3 - v1)/crange < 0.05
+ && (v2 - v1)/crange > 0.025
+ && (v2 - v3)/crange > 0.025
+ && (v2 - mincv)/crange > 0.5) {
+ double pkv; /* Peak value */
+ int pki; /* Peak index */
+ double ii, bl;
+
+#ifdef PLOT_REFRESH
+ a1logd(p->log,PFDB,"Max between %f and %f msec\n",
+ (i + PERMIN)/(double)PBPMS,(i + PWIDTH + PERMIN)/(double)PBPMS);
+#endif
+
+ /* Locate the actual peak */
+ pkv = -1.0;
+ pki = 0;
+ for (j = i; j < (i + PWIDTH); j++) {
+ if (corr[j] > pkv) {
+ pkv = corr[j];
+ pki = j;
+ }
+ }
+#ifdef PLOT_REFRESH
+ a1logd(p->log,PFDB,"Peak is at %f msec, %f corr\n", (pki + PERMIN)/(double)PBPMS, pkv);
+#endif
+
+ /* Interpolate the peak value for higher precision */
+ /* j = bigest */
+ if (corr[pki-1] > corr[pki+1]) {
+ j = pki-1;
+ k = pki+1;
+ } else {
+ j = pki+1;
+ k = pki-1;
+ }
+ bl = (corr[pki] - corr[j])/(corr[pki] - corr[k]);
+ bl = (bl + 1.0)/2.0;
+ ii = bl * pki + (1.0 - bl) * j;
+ pval = (ii + PERMIN)/(double)PBPMS;
+#ifdef PLOT_REFRESH
+ a1logd(p->log,PFDB,"Interpolated peak is at %f msec\n", pval);
+#endif
+ peaks[npeaks] = pval;
+ peakh[npeaks] = corr[pki];
+ npeaks++;
+
+ i -= PWIDTH;
+ }
+#ifdef NEVER
+ if (v2 > v1 && v2 > v3) {
+ printf("Peak rehjected:\n");
+ printf("(v3 - v1)/crange = %f < 0.05 ?\n",fabs(v3 - v1)/crange);
+ printf("(v2 - v1)/crange = %f > 0.025 ?\n",(v2 - v1)/crange);
+ printf("(v2 - v3)/crange = %f > 0.025 ?\n",(v2 - v3)/crange);
+ printf("(v2 - mincv)/crange = %f > 0.5 ?\n",(v2 - mincv)/crange);
+ }
+#endif
+ }
+ a1logd(p->log,3,"Number of peaks located = %d\n",npeaks);
+
+ } else {
+ a1logd(p->log,3,"All rejected, crange/maxcv = %f < 0.06\n",crange/maxcv);
+ }
+#undef PFDB
+
+ a1logd(p->log,3,"Number of peaks located = %d\n",npeaks);
+
+ if (npeaks > 1) { /* Compute aparent refresh rate */
+ int nfails;
+ double div, avg, ano;
+ /* Try and locate a common divisor amongst all the peaks. */
+ /* This is likely to be the underlying refresh rate. */
+ for (k = 0; k < npeaks; k++) {
+ for (j = 1; j < 25; j++) {
+ avg = ano = 0.0;
+ div = peaks[k]/(double)j;
+ if (div < 5.0)
+ continue; /* Skip anything higher than 200Hz */
+//printf("~1 trying %f Hz\n",1000.0/div);
+ for (nfails = i = 0; i < npeaks; i++) {
+ double rem, cnt;
+
+ rem = peaks[i]/div;
+ cnt = floor(rem + 0.5);
+ rem = fabs(rem - cnt);
+
+#ifdef PLOT_REFRESH
+ a1logd(p->log, 3, "remainder for peak %d = %f\n",i,rem);
+#endif
+ if (rem > 0.06) {
+ if (++nfails > 2)
+ break; /* Fail this divisor */
+ } else {
+ avg += peaks[i]; /* Already weighted by cnt */
+ ano += cnt;
+ }
+ }
+
+ if (nfails == 0 || (nfails <= 2 && npeaks >= 6))
+ break; /* Sucess */
+ /* else go and try a different divisor */
+ }
+ if (j < 25)
+ break; /* Success - found common divisor */
+ }
+ if (k >= npeaks) {
+ a1logd(p->log,3,"Failed to locate common divisor\n");
+
+ } else {
+ pval = 0.001 * avg/ano;
+ if (pval < inttime) {
+ a1logd(p->log,3,"Discarding frequency %f > sample rate %f\n",1.0/pval, 1.0/inttime);
+ } else {
+ pval = 1.0/pval; /* Convert to frequency */
+ rfreq[tix++] = pval;
+ a1logd(p->log,3,"Located frequency %f sum %f dif %f\n",pval, pval + 1.0/inttime, fabs(pval - 1.0/inttime));
+ }
+ }
+ }
+ }
+
+ if (tix >= 3) {
+
+ for (mm = 0; mm < tix; mm++) {
+ a1logd(p->log, 3, "Try %d, samp %f Hz, Meas %f Hz, Sum %f Hz, Dif %f Hz\n",mm,rsamp[mm],rfreq[mm], rsamp[mm] + rfreq[mm], fabs(rsamp[mm] - rfreq[mm]));
+ }
+
+ /* Decide if we are above the nyquist, or whether */
+ /* we have aliases of the fundamental */
+ {
+ double brange = 1e38;
+ double brate = 0.0;
+ int bsplit = -1;
+ double min, max, avg, range;
+ int split, mul, niia;
+
+ /* Compute fundamental and sub aliases at all possible splits. */
+ /* Skip the reading at the split. */
+ for (split = tix; split >= -1; split--) {
+ min = 1e38; max = -1e38; avg = 0.0; niia = 0;
+ for (mm = 0; mm < tix; mm++) {
+ double alias;
+
+ if (mm == split)
+ continue;
+ if (mm < split)
+ alias = rfreq[mm];
+ else
+ alias = fabs(rsamp[mm] - rfreq[mm]);
+
+ avg += alias;
+ niia++;
+
+ if (alias < min)
+ min = alias;
+ if (alias > max)
+ max = alias;
+ }
+ avg /= (double)niia;
+ range = (max - min)/(max + min);
+//printf("~1 split %d avg = %f, range = %f\n",split,avg,range);
+ if (range < brange) {
+ brange = range;
+ brate = avg;
+ bsplit = split;
+ }
+ }
+
+ /* Compute sub and add aliases at all possible splits */
+ /* Skip the reading at the split. */
+ for (split = tix; split >= -1; split--) {
+ min = 1e38; max = -1e38; avg = 0.0; niia = 0;
+ for (mm = 0; mm < tix; mm++) {
+ double alias;
+
+ if (mm == split)
+ continue;
+ if (mm < split)
+ alias = fabs(rsamp[mm] - rfreq[mm]);
+ else
+ alias = rsamp[mm] + rfreq[mm];
+
+ avg += alias;
+ niia++;
+
+ if (alias < min)
+ min = alias;
+ if (alias > max)
+ max = alias;
+ }
+ avg /= (double)niia;
+ range = (max - min)/(max + min);
+//printf("~1 split %d avg = %f, range = %f\n",100 + split,avg,range);
+ if (range < brange) {
+ brange = range;
+ brate = avg;
+ bsplit = 100 + split;
+ }
+ }
+
+ a1logd(p->log, 3, "Selected split %d range %f\n",bsplit,brange);
+
+ /* Hmm. Could reject result and re-try if brange is too large ? ( > 0.005 ?) */
+
+ if (brange > 0.05) {
+ a1logd(p->log, 3, "Readings are too inconsistent (brange %.1f%%) - should retry ?\n",brange * 100.0);
+ } else {
+ if (ref_rate != NULL)
+ *ref_rate = brate;
+
+ /* Error against my 85Hz CRT - GWG */
+// a1logd(p->log, 1, "Refresh rate %f Hz, error = %.4f%%\n",brate,100.0 * fabs(brate - 85.0)/(85.0));
+ return I1PRO_OK;
+ }
+ }
+ } else {
+ a1logd(p->log, 3, "Not enough tries suceeded to determine refresh rate\n");
+ }
+
+ if (ref_rate != NULL)
+ *ref_rate = 0.0;
+
+ return I1PRO_RD_NOREFR_FOUND;
+}
+#undef NFSAMPS
+#undef PBPMS
+#undef PERMIN
+#undef PERMAX
+#undef NPER
+#undef PWIDTH
+
+/* - - - - - - - - - - - - - - - - - - - - - - */
+/* i1 refspot calibration/log stored on instrument */
+/* RevA..D only! */
+
+/* Restore the reflective spot calibration information from the EEPRom */
+/* Always returns success, even if the restore fails, */
+/* which may happen for an instrument that's never been used or had calibration */
+/* written to its EEProm */
+/* RevA..D only! */
+i1pro_code i1pro_restore_refspot_cal(i1pro *p) {
+ int chsum1, *chsum2;
+ int *ip, i;
+ unsigned int count;
+ double *dp;
+ unsigned char buf[256];
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[i1p_refl_spot]; /* NOT current mode, refspot mode */
+ i1key offst = 0; /* Offset to copy to use */
+ i1pro_code ev = I1PRO_OK;
+ int o_nsen; /* Actual nsen data */
+
+ a1logd(p->log,2,"Doing Restoring reflective spot calibration information from the EEProm\n");
+
+ chsum1 = m->data->checksum(m->data, 0);
+ if ((chsum2 = m->data->get_int(m->data, key_checksum, 0)) == NULL || chsum1 != *chsum2) {
+ offst = key_2logoff;
+ chsum1 = m->data->checksum(m->data, key_2logoff);
+ if ((chsum2 = m->data->get_int(m->data, key_checksum + key_2logoff, 0)) == NULL
+ || chsum1 != *chsum2) {
+ a1logd(p->log,2,"Neither EEPRom checksum was valid\n");
+ return I1PRO_OK;
+ }
+ }
+
+ /* Get the calibration gain mode */
+ if ((ip = m->data->get_ints(m->data, &count, key_gainmode + offst)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to read calibration gain mode from EEPRom\n");
+ return I1PRO_OK;
+ }
+ if (ip[0] == 0) {
+#ifdef USE_HIGH_GAIN_MODE
+ s->gainmode = 1;
+#else
+ s->gainmode = 0;
+ a1logd(p->log,2,"Calibration gain mode was high, and high gain not compiled in\n");
+ return I1PRO_OK;
+#endif /* !USE_HIGH_GAIN_MODE */
+ } else
+ s->gainmode = 0;
+
+ /* Get the calibration integrattion time */
+ if ((dp = m->data->get_doubles(m->data, &count, key_inttime + offst)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to read calibration integration time from EEPRom\n");
+ return I1PRO_OK;
+ }
+ s->inttime = dp[0];
+ if (s->inttime < m->min_int_time) /* Hmm. EEprom is occasionaly screwed up */
+ s->inttime = m->min_int_time;
+
+ /* Get the dark data */
+ if ((ip = m->data->get_ints(m->data, &count, key_darkreading + offst)) == NULL
+ || count != 128) {
+ a1logv(p->log,1,"Failed to read calibration dark data from EEPRom\n");
+ return I1PRO_OK;
+ }
+
+ /* Convert back to a single raw big endian instrument readings */
+ for (i = 0; i < 128; i++) {
+ buf[i * 2 + 0] = (ip[i] >> 8) & 0xff;
+ buf[i * 2 + 1] = ip[i] & 0xff;
+ }
+
+ /* Convert to calibration data */
+ a1logd(p->log,3,"Calling black calibration_2 calc with nummeas %d, inttime %f, gainmode %d\n", 1, s->inttime,s->gainmode);
+ o_nsen = m->nsen;
+ m->nsen = 128; /* Assume EEprom cal data is <= Rev D format */
+ if ((ev = i1pro_dark_measure_2(p, s->dark_data, 1, s->inttime, s->gainmode,
+ buf, 256)) != I1PRO_OK) {
+ a1logd(p->log,2,"Failed to convert EEProm dark data to calibration\n");
+ m->nsen = o_nsen;
+ return I1PRO_OK;
+ }
+
+ /* We've sucessfully restored the dark calibration */
+ s->dark_valid = 1;
+ s->ddate = m->caldate;
+
+ /* Get the white calibration data */
+ if ((ip = m->data->get_ints(m->data, &count, key_whitereading + offst)) == NULL
+ || count != 128) {
+ a1logd(p->log,2,"Failed to read calibration white data from EEPRom\n");
+ m->nsen = o_nsen;
+ return I1PRO_OK;
+ }
+
+ /* Convert back to a single raw big endian instrument readings */
+ for (i = 0; i < 128; i++) {
+ buf[i * 2 + 0] = (ip[i] >> 8) & 0xff;
+ buf[i * 2 + 1] = ip[i] & 0xff;
+ }
+
+ /* Convert to calibration data */
+ m->nsen = 128; /* Assume EEprom cal data is <= Rev D format */
+ if ((ev = i1pro_whitemeasure_buf(p, s->cal_factor[0], s->cal_factor[1], s->white_data,
+ s->inttime, s->gainmode, buf)) != I1PRO_OK) {
+ /* This may happen for an instrument that's never been used */
+ a1logd(p->log,2,"Failed to convert EEProm white data to calibration\n");
+ m->nsen = o_nsen;
+ return I1PRO_OK;
+ }
+ m->nsen = o_nsen;
+
+ /* Check a reflective white measurement, and check that */
+ /* it seems reasonable. Return I1PRO_OK if it is, error if not. */
+ /* (Using cal_factor[] as temp.) */
+ if ((ev = i1pro_check_white_reference1(p, s->cal_factor[0])) != I1PRO_OK) {
+ /* This may happen for an instrument that's never been used */
+ a1logd(p->log,2,"Failed to convert EEProm white data to calibration\n");
+ return I1PRO_OK;
+ }
+ /* Compute a calibration factor given the reading of the white reference. */
+ i1pro_compute_white_cal(p, s->cal_factor[0], m->white_ref[0], s->cal_factor[0],
+ s->cal_factor[1], m->white_ref[1], s->cal_factor[1]);
+
+ /* We've sucessfully restored the calibration */
+ s->cal_valid = 1;
+ s->cfdate = m->caldate;
+
+ return I1PRO_OK;
+}
+
+/* Save the reflective spot calibration information to the EEPRom data object. */
+/* Note we don't actually write to the EEProm here! */
+/* For RevA..D only! */
+static i1pro_code i1pro_set_log_data(i1pro *p) {
+ int *ip, i;
+ unsigned int count;
+ double *dp;
+ double absmeas[128];
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[i1p_refl_spot]; /* NOT current mode, refspot mode */
+ i1key offst = 0; /* Offset to copy to use */
+ i1pro_code ev = I1PRO_OK;
+
+ a1logd(p->log,3,"i1pro_set_log_data called\n");
+
+ if (s->dark_valid == 0 || s->cal_valid == 0)
+ return I1PRO_INT_NO_CAL_TO_SAVE;
+
+ /* Set the calibration gain mode */
+ if ((ip = m->data->get_ints(m->data, &count, key_gainmode + offst)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access calibration gain mode from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ if (s->gainmode == 0)
+ ip[0] = 1;
+ else
+ ip[0] = 0;
+
+ /* Set the calibration integration time */
+ if ((dp = m->data->get_doubles(m->data, &count, key_inttime + offst)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to read calibration integration time from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ dp[0] = s->inttime;
+
+ /* Set the dark data */
+ if ((ip = m->data->get_ints(m->data, &count, key_darkreading + offst)) == NULL
+ || count != 128) {
+ a1logd(p->log,2,"Failed to access calibration dark data from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+
+ /* Convert abs dark_data to raw data */
+ if ((ev = i1pro_absraw_to_meas(p, ip, s->dark_data, s->inttime, s->gainmode)) != I1PRO_OK)
+ return ev;
+
+ /* Add back black level to white data */
+ for (i = 0; i < 128; i++)
+ absmeas[i] = s->white_data[i] + s->dark_data[i];
+
+ /* Get the white data */
+ if ((ip = m->data->get_ints(m->data, &count, key_whitereading + offst)) == NULL
+ || count != 128) {
+ a1logd(p->log,2,"Failed to access calibration white data from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+
+ /* Convert abs white_data to raw data */
+ if ((ev = i1pro_absraw_to_meas(p, ip, absmeas, s->inttime, s->gainmode)) != I1PRO_OK)
+ return ev;
+
+ /* Set all the log counters */
+
+ /* Total Measure (Emis/Remis/Ambient/Trans/Cal) count */
+ if ((ip = m->data->get_ints(m->data, &count, key_meascount)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access meascount log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ ip[0] = m->meascount;
+
+ /* Remspotcal last calibration date */
+ if ((ip = m->data->get_ints(m->data, &count, key_caldate)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access caldate log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ ip[0] = m->caldate;
+
+ /* Remission spot measure count at last Remspotcal. */
+ if ((ip = m->data->get_ints(m->data, &count, key_calcount)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access calcount log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ ip[0] = m->calcount;
+
+ /* Last remision spot reading integration time */
+ if ((dp = m->data->get_doubles(m->data, &count, key_rpinttime)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access rpinttime log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ dp[0] = m->rpinttime;
+
+ /* Remission spot measure count */
+ if ((ip = m->data->get_ints(m->data, &count, key_rpcount)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access rpcount log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ ip[0] = m->rpcount;
+
+ /* Remission scan measure count (??) */
+ if ((ip = m->data->get_ints(m->data, &count, key_acount)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access acount log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ ip[0] = m->acount;
+
+ /* Total lamp usage time in seconds (??) */
+ if ((dp = m->data->get_doubles(m->data, &count, key_lampage)) == NULL || count < 1) {
+ a1logd(p->log,2,"Failed to access lampage log counter from EEPRom\n");
+ return I1PRO_INT_EEPROM_DATA_MISSING;
+ }
+ dp[0] = m->lampage;
+
+ a1logd(p->log,5,"i1pro_set_log_data done\n");
+
+ return I1PRO_OK;
+}
+
+/* Update the single remission calibration and instrument usage log */
+/* For RevA..D only! */
+i1pro_code i1pro_update_log(i1pro *p) {
+ i1pro_code ev = I1PRO_OK;
+#ifdef ENABLE_WRITE
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char *buf; /* Buffer to write to EEProm */
+ unsigned int len;
+
+ a1logd(p->log,5,"i1pro_update_log:\n");
+
+ /* Copy refspot calibration and log data to EEProm data store */
+ if ((ev = i1pro_set_log_data(p)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_update_log i1pro_set_log_data failed\n");
+ return ev;
+ }
+
+ /* Compute checksum and serialise into buffer ready to write */
+ if ((ev = m->data->prep_section1(m->data, &buf, &len)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_update_log prep_section1 failed\n");
+ return ev;
+ }
+
+ /* First copy of log */
+ if ((ev = i1pro_writeEEProm(p, buf, 0x0000, len)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_update_log i1pro_writeEEProm 0x0000 failed\n");
+ return ev;
+ }
+ /* Second copy of log */
+ if ((ev = i1pro_writeEEProm(p, buf, 0x0800, len)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_update_log i1pro_writeEEProm 0x0800 failed\n");
+ return ev;
+ }
+ free(buf);
+
+ a1logd(p->log,5,"i1pro_update_log done\n");
+#else
+ a1logd(p->log,5,"i1pro_update_log: skipped as EPRom write is disabled\n");
+#endif
+
+ return ev;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Save the calibration for all modes, stored on local system */
+
+#ifdef ENABLE_NONVCAL
+
+/* non-volatile save/restor state */
+typedef struct {
+ int ef; /* Error flag, 1 = write failed, 2 = close failed */
+ unsigned int chsum; /* Checksum */
+ int nbytes; /* Number of bytes checksummed */
+} i1pnonv;
+
+static void update_chsum(i1pnonv *x, unsigned char *p, int nn) {
+ int i;
+ for (i = 0; i < nn; i++, p++)
+ x->chsum = ((x->chsum << 13) | (x->chsum >> (32-13))) + *p;
+ x->nbytes += nn;
+}
+
+/* Write an array of ints to the file. Set the error flag to nz on error */
+static void write_ints(i1pnonv *x, FILE *fp, int *dp, int n) {
+
+ if (fwrite((void *)dp, sizeof(int), n, fp) != n) {
+ x->ef = 1;
+ } else {
+ update_chsum(x, (unsigned char *)dp, n * sizeof(int));
+ }
+}
+
+/* Write an array of doubles to the file. Set the error flag to nz on error */
+static void write_doubles(i1pnonv *x, FILE *fp, double *dp, int n) {
+
+ if (fwrite((void *)dp, sizeof(double), n, fp) != n) {
+ x->ef = 1;
+ } else {
+ update_chsum(x, (unsigned char *)dp, n * sizeof(double));
+ }
+}
+
+/* Write an array of time_t's to the file. Set the error flag to nz on error */
+/* (This will cause file checksum fail if different executables on the same */
+/* system have different time_t values) */
+static void write_time_ts(i1pnonv *x, FILE *fp, time_t *dp, int n) {
+
+ if (fwrite((void *)dp, sizeof(time_t), n, fp) != n) {
+ x->ef = 1;
+ } else {
+ update_chsum(x, (unsigned char *)dp, n * sizeof(time_t));
+ }
+}
+
+/* Read an array of ints from the file. Set the error flag to nz on error */
+static void read_ints(i1pnonv *x, FILE *fp, int *dp, int n) {
+
+ if (fread((void *)dp, sizeof(int), n, fp) != n) {
+ x->ef = 1;
+ } else {
+ update_chsum(x, (unsigned char *)dp, n * sizeof(int));
+ }
+}
+
+/* Read an array of doubles from the file. Set the error flag to nz on error */
+static void read_doubles(i1pnonv *x, FILE *fp, double *dp, int n) {
+
+ if (fread((void *)dp, sizeof(double), n, fp) != n) {
+ x->ef = 1;
+ } else {
+ update_chsum(x, (unsigned char *)dp, n * sizeof(double));
+ }
+}
+
+/* Read an array of time_t's from the file. Set the error flag to nz on error */
+/* (This will cause file checksum fail if different executables on the same */
+/* system have different time_t values) */
+static void read_time_ts(i1pnonv *x, FILE *fp, time_t *dp, int n) {
+
+ if (fread((void *)dp, sizeof(time_t), n, fp) != n) {
+ x->ef = 1;
+ } else {
+ update_chsum(x, (unsigned char *)dp, n * sizeof(time_t));
+ }
+}
+
+i1pro_code i1pro_save_calibration(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ i1pro_state *s;
+ int i;
+ char nmode[10];
+ char cal_name[100]; /* Name */
+ char **cal_paths = NULL;
+ int no_paths = 0;
+ FILE *fp;
+ i1pnonv x;
+ int ss;
+ int argyllversion = ARGYLL_VERSION;
+
+ strcpy(nmode, "w");
+#if !defined(O_CREAT) && !defined(_O_CREAT)
+# error "Need to #include fcntl.h!"
+#endif
+#if defined(O_BINARY) || defined(_O_BINARY)
+ strcat(nmode, "b");
+#endif
+
+ /* Create the file name */
+ sprintf(cal_name, "ArgyllCMS/.i1p_%d.cal", m->serno);
+ if ((no_paths = xdg_bds(NULL, &cal_paths, xdg_cache, xdg_write, xdg_user, cal_name)) < 1) {
+ a1logd(p->log,1,"i1pro_save_calibration xdg_bds returned no paths\n");
+ return I1PRO_INT_CAL_SAVE;
+ }
+
+ a1logd(p->log,2,"i1pro_save_calibration saving to file '%s'\n",cal_paths[0]);
+
+ if (create_parent_directories(cal_paths[0])
+ || (fp = fopen(cal_paths[0], nmode)) == NULL) {
+ a1logd(p->log,2,"i1pro_save_calibration failed to open file for writing\n");
+ xdg_free(cal_paths, no_paths);
+ return I1PRO_INT_CAL_SAVE;
+ }
+
+ x.ef = 0;
+ x.chsum = 0;
+ x.nbytes = 0;
+
+ /* A crude structure signature */
+ ss = sizeof(i1pro_state) + sizeof(i1proimp);
+
+ /* Some file identification */
+ write_ints(&x, fp, &argyllversion, 1);
+ write_ints(&x, fp, &ss, 1);
+ write_ints(&x, fp, &m->serno, 1);
+ write_ints(&x, fp, (int *)&m->nraw, 1);
+ write_ints(&x, fp, (int *)&m->nwav[0], 1);
+ write_ints(&x, fp, (int *)&m->nwav[1], 1);
+
+ /* For each mode, save the calibration if it's valid */
+ for (i = 0; i < i1p_no_modes; i++) {
+ s = &m->ms[i];
+
+ /* Mode identification */
+ write_ints(&x, fp, &s->emiss, 1);
+ write_ints(&x, fp, &s->trans, 1);
+ write_ints(&x, fp, &s->reflective, 1);
+ write_ints(&x, fp, &s->scan, 1);
+ write_ints(&x, fp, &s->flash, 1);
+ write_ints(&x, fp, &s->ambient, 1);
+ write_ints(&x, fp, &s->adaptive, 1);
+
+ /* Configuration calibration is valid for */
+ write_ints(&x, fp, &s->gainmode, 1);
+ write_doubles(&x, fp, &s->inttime, 1);
+
+ /* Calibration information */
+ write_ints(&x, fp, &s->wl_valid, 1);
+ write_time_ts(&x, fp, &s->wldate, 1);
+ write_doubles(&x, fp, &s->wl_led_off, 1);
+ write_ints(&x, fp, &s->dark_valid, 1);
+ write_time_ts(&x, fp, &s->ddate, 1);
+ write_doubles(&x, fp, &s->dark_int_time, 1);
+ write_doubles(&x, fp, s->dark_data-1, m->nraw+1);
+ write_doubles(&x, fp, &s->dark_int_time2, 1);
+ write_doubles(&x, fp, s->dark_data2-1, m->nraw+1);
+ write_doubles(&x, fp, &s->dark_int_time3, 1);
+ write_doubles(&x, fp, s->dark_data3-1, m->nraw+1);
+ write_ints(&x, fp, &s->dark_gain_mode, 1);
+
+ if (!s->emiss) {
+ write_ints(&x, fp, &s->cal_valid, 1);
+ write_time_ts(&x, fp, &s->cfdate, 1);
+ write_doubles(&x, fp, s->cal_factor[0], m->nwav[0]);
+ write_doubles(&x, fp, s->cal_factor[1], m->nwav[1]);
+ write_doubles(&x, fp, s->white_data-1, m->nraw+1);
+ }
+
+ write_ints(&x, fp, &s->idark_valid, 1);
+ write_time_ts(&x, fp, &s->iddate, 1);
+ write_doubles(&x, fp, s->idark_int_time, 4);
+ write_doubles(&x, fp, s->idark_data[0]-1, m->nraw+1);
+ write_doubles(&x, fp, s->idark_data[1]-1, m->nraw+1);
+ write_doubles(&x, fp, s->idark_data[2]-1, m->nraw+1);
+ write_doubles(&x, fp, s->idark_data[3]-1, m->nraw+1);
+ }
+
+ a1logd(p->log,3,"nbytes = %d, Checkum = 0x%x\n",x.nbytes,x.chsum);
+ write_ints(&x, fp, (int *)&x.chsum, 1);
+
+ if (fclose(fp) != 0)
+ x.ef = 2;
+
+ if (x.ef != 0) {
+ a1logd(p->log,2,"Writing calibration file failed with %d\n",x.ef);
+ delete_file(cal_paths[0]);
+ return I1PRO_INT_CAL_SAVE;
+ } else {
+ a1logd(p->log,2,"Writing calibration file succeeded\n");
+ }
+ xdg_free(cal_paths, no_paths);
+
+ return ev;
+}
+
+/* Restore the all modes calibration from the local system */
+i1pro_code i1pro_restore_calibration(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ i1pro_state *s, ts;
+ int i, j;
+ char nmode[10];
+ char cal_name[100]; /* Name */
+ char **cal_paths = NULL;
+ int no_paths = 0;
+ FILE *fp;
+ i1pnonv x;
+ int argyllversion;
+ int ss, serno, nraw, nwav0, nwav1, nbytes, chsum1, chsum2;
+
+ strcpy(nmode, "r");
+#if !defined(O_CREAT) && !defined(_O_CREAT)
+# error "Need to #include fcntl.h!"
+#endif
+#if defined(O_BINARY) || defined(_O_BINARY)
+ strcat(nmode, "b");
+#endif
+ /* Create the file name */
+ sprintf(cal_name, "ArgyllCMS/.i1p_%d.cal" SSEPS "color/.i1p_%d.cal", m->serno, m->serno);
+ if ((no_paths = xdg_bds(NULL, &cal_paths, xdg_cache, xdg_read, xdg_user, cal_name)) < 1) {
+ a1logd(p->log,2,"i1pro_restore_calibration xdg_bds failed to locate file'\n");
+ return I1PRO_INT_CAL_RESTORE;
+ }
+
+ a1logd(p->log,2,"i1pro_restore_calibration restoring from file '%s'\n",cal_paths[0]);
+
+ /* Check the last modification time */
+ {
+ struct sys_stat sbuf;
+
+ if (sys_stat(cal_paths[0], &sbuf) == 0) {
+ m->lo_secs = time(NULL) - sbuf.st_mtime;
+ a1logd(p->log,2,"i1pro_restore_calibration: %d secs from instrument last open\n",m->lo_secs);
+ } else {
+ a1logd(p->log,2,"i1pro_restore_calibration: stat on file failed\n");
+ }
+ }
+
+ if ((fp = fopen(cal_paths[0], nmode)) == NULL) {
+ a1logd(p->log,2,"i1pro_restore_calibration failed to open file for reading\n");
+ xdg_free(cal_paths, no_paths);
+ return I1PRO_INT_CAL_RESTORE;
+ }
+
+ x.ef = 0;
+ x.chsum = 0;
+ x.nbytes = 0;
+
+ /* Check the file identification */
+ read_ints(&x, fp, &argyllversion, 1);
+ read_ints(&x, fp, &ss, 1);
+ read_ints(&x, fp, &serno, 1);
+ read_ints(&x, fp, &nraw, 1);
+ read_ints(&x, fp, &nwav0, 1);
+ read_ints(&x, fp, &nwav1, 1);
+ if (x.ef != 0
+ || argyllversion != ARGYLL_VERSION
+ || ss != (sizeof(i1pro_state) + sizeof(i1proimp))
+ || serno != m->serno
+ || nraw != m->nraw
+ || nwav0 != m->nwav[0]
+ || nwav1 != m->nwav[1]) {
+ a1logd(p->log,2,"Identification didn't verify\n");
+ goto reserr;
+ }
+
+ /* Do a dummy read to check the checksum */
+ for (i = 0; i < i1p_no_modes; i++) {
+ int di;
+ double dd;
+ time_t dt;
+ int emiss, trans, reflective, ambient, scan, flash, adaptive;
+
+ s = &m->ms[i];
+
+ /* Mode identification */
+ read_ints(&x, fp, &emiss, 1);
+ read_ints(&x, fp, &trans, 1);
+ read_ints(&x, fp, &reflective, 1);
+ read_ints(&x, fp, &scan, 1);
+ read_ints(&x, fp, &flash, 1);
+ read_ints(&x, fp, &ambient, 1);
+ read_ints(&x, fp, &adaptive, 1);
+
+ /* Configuration calibration is valid for */
+ read_ints(&x, fp, &di, 1);
+ read_doubles(&x, fp, &dd, 1);
+
+ /* Calibration information */
+ read_ints(&x, fp, &di, 1);
+ read_time_ts(&x, fp, &dt, 1);
+ read_doubles(&x, fp, &dd, 1);
+
+ read_ints(&x, fp, &di, 1);
+ read_time_ts(&x, fp, &dt, 1);
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ read_ints(&x, fp, &di, 1);
+
+ if (!s->emiss) {
+ read_ints(&x, fp, &di, 1);
+ read_time_ts(&x, fp, &dt, 1);
+ for (j = 0; j < m->nwav[0]; j++)
+ read_doubles(&x, fp, &dd, 1);
+ for (j = 0; j < m->nwav[1]; j++)
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ }
+
+ read_ints(&x, fp, &di, 1);
+ read_time_ts(&x, fp, &dt, 1);
+ for (j = 0; j < 4; j++)
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ for (j = -1; j < m->nraw; j++)
+ read_doubles(&x, fp, &dd, 1);
+ }
+
+ chsum1 = x.chsum;
+ nbytes = x.nbytes;
+ read_ints(&x, fp, &chsum2, 1);
+
+ if (x.ef != 0
+ || chsum1 != chsum2) {
+ a1logd(p->log,2,"Checksum didn't verify, bytes %d, got 0x%x, expected 0x%x\n",nbytes,chsum1, chsum2);
+ goto reserr;
+ }
+
+ rewind(fp);
+ x.ef = 0;
+ x.chsum = 0;
+ x.nbytes = 0;
+
+ /* Allocate space in temp structure */
+
+ ts.dark_data = dvectorz(-1, m->nraw-1);
+ ts.dark_data2 = dvectorz(-1, m->nraw-1);
+ ts.dark_data3 = dvectorz(-1, m->nraw-1);
+ ts.cal_factor[0] = dvectorz(0, m->nwav[0]-1);
+ ts.cal_factor[1] = dvectorz(0, m->nwav[1]-1);
+ ts.white_data = dvectorz(-1, m->nraw-1);
+ ts.idark_data = dmatrixz(0, 3, -1, m->nraw-1);
+
+ /* Read the identification */
+ read_ints(&x, fp, &argyllversion, 1);
+ read_ints(&x, fp, &ss, 1);
+ read_ints(&x, fp, &m->serno, 1);
+ read_ints(&x, fp, (int *)&m->nraw, 1);
+ read_ints(&x, fp, (int *)&m->nwav[0], 1);
+ read_ints(&x, fp, (int *)&m->nwav[1], 1);
+
+ /* For each mode, restore the calibration if it's valid */
+ for (i = 0; i < i1p_no_modes; i++) {
+ s = &m->ms[i];
+
+ /* Mode identification */
+ read_ints(&x, fp, &ts.emiss, 1);
+ read_ints(&x, fp, &ts.trans, 1);
+ read_ints(&x, fp, &ts.reflective, 1);
+ read_ints(&x, fp, &ts.scan, 1);
+ read_ints(&x, fp, &ts.flash, 1);
+ read_ints(&x, fp, &ts.ambient, 1);
+ read_ints(&x, fp, &ts.adaptive, 1);
+
+ /* Configuration calibration is valid for */
+ read_ints(&x, fp, &ts.gainmode, 1);
+ read_doubles(&x, fp, &ts.inttime, 1);
+
+ /* Calibration information: */
+
+ /* Wavelength */
+ read_ints(&x, fp, &ts.wl_valid, 1);
+ read_time_ts(&x, fp, &ts.wldate, 1);
+ read_doubles(&x, fp, &ts.wl_led_off, 1);
+
+ /* Static Dark */
+ read_ints(&x, fp, &ts.dark_valid, 1);
+ read_time_ts(&x, fp, &ts.ddate, 1);
+ read_doubles(&x, fp, &ts.dark_int_time, 1);
+ read_doubles(&x, fp, ts.dark_data-1, m->nraw+1);
+ read_doubles(&x, fp, &ts.dark_int_time2, 1);
+ read_doubles(&x, fp, ts.dark_data2-1, m->nraw+1);
+ read_doubles(&x, fp, &ts.dark_int_time3, 1);
+ read_doubles(&x, fp, ts.dark_data3-1, m->nraw+1);
+ read_ints(&x, fp, &ts.dark_gain_mode, 1);
+
+ if (!ts.emiss) {
+ /* Reflective */
+ read_ints(&x, fp, &ts.cal_valid, 1);
+ read_time_ts(&x, fp, &ts.cfdate, 1);
+ read_doubles(&x, fp, ts.cal_factor[0], m->nwav[0]);
+ read_doubles(&x, fp, ts.cal_factor[1], m->nwav[1]);
+ read_doubles(&x, fp, ts.white_data-1, m->nraw+1);
+ }
+
+ /* Adaptive Dark */
+ read_ints(&x, fp, &ts.idark_valid, 1);
+ read_time_ts(&x, fp, &ts.iddate, 1);
+ read_doubles(&x, fp, ts.idark_int_time, 4);
+ read_doubles(&x, fp, ts.idark_data[0]-1, m->nraw+1);
+ read_doubles(&x, fp, ts.idark_data[1]-1, m->nraw+1);
+ read_doubles(&x, fp, ts.idark_data[2]-1, m->nraw+1);
+ read_doubles(&x, fp, ts.idark_data[3]-1, m->nraw+1);
+
+ /* If the configuration for this mode matches */
+ /* that of the calibration, restore the calibration */
+ /* for this mode. */
+ if (x.ef == 0 /* No read error */
+ && s->emiss == ts.emiss
+ && s->trans == ts.trans
+ && s->reflective == ts.reflective
+ && s->scan == ts.scan
+ && s->flash == ts.flash
+ && s->ambient == ts.ambient
+ && s->adaptive == ts.adaptive
+ && (s->adaptive || fabs(s->inttime - ts.inttime) < 0.01)
+ && (s->adaptive || fabs(s->dark_int_time - ts.dark_int_time) < 0.01)
+ && (s->adaptive || fabs(s->dark_int_time2 - ts.dark_int_time2) < 0.01)
+ && (s->adaptive || fabs(s->dark_int_time3 - ts.dark_int_time3) < 0.01)
+ && (!s->adaptive || fabs(s->idark_int_time[0] - ts.idark_int_time[0]) < 0.01)
+ && (!s->adaptive || fabs(s->idark_int_time[1] - ts.idark_int_time[1]) < 0.01)
+ && (!s->adaptive || fabs(s->idark_int_time[2] - ts.idark_int_time[2]) < 0.01)
+ && (!s->adaptive || fabs(s->idark_int_time[3] - ts.idark_int_time[3]) < 0.01)
+ ) {
+ /* Copy all the fields read above */
+ s->emiss = ts.emiss;
+ s->trans = ts.trans;
+ s->reflective = ts.reflective;
+ s->scan = ts.scan;
+ s->flash = ts.flash;
+ s->ambient = ts.ambient;
+ s->adaptive = ts.adaptive;
+
+ s->gainmode = ts.gainmode;
+ s->inttime = ts.inttime;
+
+ s->wl_valid = ts.wl_valid;
+ s->wldate = ts.wldate;
+ s->wl_led_off = ts.wl_led_off;
+
+ s->dark_valid = ts.dark_valid;
+ s->ddate = ts.ddate;
+ s->dark_int_time = ts.dark_int_time;
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data[j] = ts.dark_data[j];
+ s->dark_int_time2 = ts.dark_int_time2;
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data2[j] = ts.dark_data2[j];
+ s->dark_int_time3 = ts.dark_int_time3;
+ for (j = -1; j < m->nraw; j++)
+ s->dark_data3[j] = ts.dark_data3[j];
+ s->dark_gain_mode = ts.dark_gain_mode;
+ if (!ts.emiss) {
+ s->cal_valid = ts.cal_valid;
+ s->cfdate = ts.cfdate;
+ for (j = 0; j < m->nwav[0]; j++)
+ s->cal_factor[0][j] = ts.cal_factor[0][j];
+ for (j = 0; j < m->nwav[1]; j++)
+ s->cal_factor[1][j] = ts.cal_factor[1][j];
+ for (j = -1; j < m->nraw; j++)
+ s->white_data[j] = ts.white_data[j];
+ }
+ s->idark_valid = ts.idark_valid;
+ s->iddate = ts.iddate;
+ for (j = 0; j < 4; j++)
+ s->idark_int_time[j] = ts.idark_int_time[j];
+ for (j = -1; j < m->nraw; j++)
+ s->idark_data[0][j] = ts.idark_data[0][j];
+ for (j = -1; j < m->nraw; j++)
+ s->idark_data[1][j] = ts.idark_data[1][j];
+ for (j = -1; j < m->nraw; j++)
+ s->idark_data[2][j] = ts.idark_data[2][j];
+ for (j = -1; j < m->nraw; j++)
+ s->idark_data[3][j] = ts.idark_data[3][j];
+
+ } else {
+ a1logd(p->log,2,"Not restoring cal for mode %d since params don't match:\n",i);
+ a1logd(p->log,2,"emis = %d : %d, trans = %d : %d, ref = %d : %d\n",s->emiss,ts.emiss,s->trans,ts.trans,s->reflective,ts.reflective);
+ a1logd(p->log,2,"scan = %d : %d, flash = %d : %d, ambi = %d : %d, adapt = %d : %d\n",s->scan,ts.scan,s->flash,ts.flash,s->ambient,ts.ambient,s->adaptive,ts.adaptive);
+ a1logd(p->log,2,"inttime = %f : %f\n",s->inttime,ts.inttime);
+ a1logd(p->log,2,"darkit1 = %f : %f, 2 = %f : %f, 3 = %f : %f\n",s->dark_int_time,ts.dark_int_time,s->dark_int_time2,ts.dark_int_time2,s->dark_int_time3,ts.dark_int_time3);
+ a1logd(p->log,2,"idarkit0 = %f : %f, 1 = %f : %f, 2 = %f : %f, 3 = %f : %f\n",s->idark_int_time[0],ts.idark_int_time[0],s->idark_int_time[1],ts.idark_int_time[1],s->idark_int_time[2],ts.idark_int_time[2],s->idark_int_time[3],ts.idark_int_time[3]);
+ }
+ }
+
+ /* Free up temporary space */
+ free_dvector(ts.dark_data, -1, m->nraw-1);
+ free_dvector(ts.dark_data2, -1, m->nraw-1);
+ free_dvector(ts.dark_data3, -1, m->nraw-1);
+ free_dvector(ts.white_data, -1, m->nraw-1);
+ free_dmatrix(ts.idark_data, 0, 3, -1, m->nraw-1);
+
+ free_dvector(ts.cal_factor[0], 0, m->nwav[0]-1);
+ free_dvector(ts.cal_factor[1], 0, m->nwav[1]-1);
+
+ a1logd(p->log,5,"i1pro_restore_calibration done\n");
+ reserr:;
+
+ fclose(fp);
+ xdg_free(cal_paths, no_paths);
+
+ return ev;
+}
+
+i1pro_code i1pro_touch_calibration(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ char cal_name[100]; /* Name */
+ char **cal_paths = NULL;
+ int no_paths = 0;
+ int rv;
+
+ /* Locate the file name */
+ sprintf(cal_name, "ArgyllCMS/.i1p_%d.cal" SSEPS "color/.i1p_%d.cal", m->serno, m->serno);
+ if ((no_paths = xdg_bds(NULL, &cal_paths, xdg_cache, xdg_read, xdg_user, cal_name)) < 1) {
+ a1logd(p->log,2,"i1pro_restore_calibration xdg_bds failed to locate file'\n");
+ return I1PRO_INT_CAL_TOUCH;
+ }
+
+ a1logd(p->log,2,"i1pro_touch_calibration touching file '%s'\n",cal_paths[0]);
+
+ if ((rv = sys_utime(cal_paths[0], NULL)) != 0) {
+ a1logd(p->log,2,"i1pro_touch_calibration failed with %d\n",rv);
+ xdg_free(cal_paths, no_paths);
+ return I1PRO_INT_CAL_TOUCH;
+ }
+ xdg_free(cal_paths, no_paths);
+
+ return ev;
+}
+
+#endif /* ENABLE_NONVCAL */
+
+/* ============================================================ */
+/* Intermediate routines - composite commands/processing */
+
+/* Some sort of configuration needed get instrument ready. */
+/* Does it have a sleep mode that we need to deal with ?? */
+/* Note this always does a reset. */
+i1pro_code
+i1pro_establish_high_power(i1pro *p) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ int i;
+
+ /* Get the current misc. status */
+ if ((ev = i1pro_getmisc(p, &m->fwrev, NULL, &m->maxpve, NULL, &m->powmode)) != I1PRO_OK)
+ return ev;
+
+ if (m->powmode != 8) { /* In high power mode */
+ if ((ev = i1pro_reset(p, 0x1f)) != I1PRO_OK)
+ return ev;
+
+ return I1PRO_OK;
+ }
+
+ a1logd(p->log,4,"Switching to high power mode\n");
+
+ /* Switch to high power mode */
+ if ((ev = i1pro_reset(p, 1)) != I1PRO_OK)
+ return ev;
+
+ /* Wait up to 1.5 seconds for it return high power indication */
+ for (i = 0; i < 15; i++) {
+
+ /* Get the current misc. status */
+ if ((ev = i1pro_getmisc(p, &m->fwrev, NULL, &m->maxpve, NULL, &m->powmode)) != I1PRO_OK)
+ return ev;
+
+ if (m->powmode != 8) { /* In high power mode */
+ if ((ev = i1pro_reset(p, 0x1f)) != I1PRO_OK)
+ return ev;
+
+ return I1PRO_OK;
+ }
+
+ msec_sleep(100);
+ }
+
+ /* Failed to switch into high power mode */
+ return I1PRO_HW_HIGHPOWERFAIL;
+}
+
+/* Take a dark reference measurement - part 1 */
+i1pro_code i1pro_dark_measure_1(
+ i1pro *p,
+ int nummeas, /* Number of readings to take */
+ double *inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ unsigned char *buf, /* USB reading buffer to use */
+ unsigned int bsize /* Size of buffer */
+) {
+ i1pro_code ev = I1PRO_OK;
+
+ if (nummeas <= 0)
+ return I1PRO_INT_ZEROMEASURES;
+
+ if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p_dark_cal)) != I1PRO_OK)
+ return ev;
+
+ if ((ev = i1pro_readmeasurement(p, nummeas, 0, buf, bsize, NULL, i1p_dark_cal)) != I1PRO_OK)
+ return ev;
+
+ return ev;
+}
+
+/* Take a dark reference measurement - part 2 */
+i1pro_code i1pro_dark_measure_2(
+ i1pro *p,
+ double *absraw, /* Return array [-1 nraw] of absraw values */
+ int nummeas, /* Number of readings to take */
+ double inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ unsigned char *buf, /* raw USB reading buffer to process */
+ unsigned int bsize /* Buffer size to process */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ double **multimes; /* Multiple measurement results */
+ double sensavg; /* Overall average of sensor readings */
+ double satthresh; /* Saturation threshold */
+ double darkthresh; /* Dark threshold */
+ int rv;
+
+ multimes = dmatrix(0, nummeas-1, -1, m->nraw-1); /* -1 is RevE shielded cells values */
+
+ if (gainmode == 0)
+ satthresh = m->sens_sat0;
+ else
+ satthresh = m->sens_sat1;
+
+ darkthresh = m->sens_dark + inttime * 900.0;
+ if (gainmode)
+ darkthresh *= m->highgain;
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nummeas, inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ return ev;
+ }
+
+ satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);
+ darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);
+
+ /* Average a set of measurements into one. */
+ /* Return zero if readings are consistent and not saturated. */
+ /* Return nz with bit 1 set if the readings are not consistent */
+ /* Return nz with bit 2 set if the readings are saturated */
+ /* Return the highest individual element. */
+ /* Return the overall average. */
+ rv = i1pro_average_multimeas(p, absraw, multimes, nummeas, NULL, &sensavg,
+ satthresh, darkthresh);
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+
+#ifdef PLOT_DEBUG
+ printf("Average absolute sensor readings, average = %f, satthresh %f:\n",sensavg, satthresh);
+ plot_raw(absraw);
+#endif
+
+ if (rv & 1)
+ return I1PRO_RD_DARKREADINCONS;
+
+ if (rv & 2)
+ return I1PRO_RD_SENSORSATURATED;
+
+ a1logd(p->log,3,"Dark threshold = %f\n",darkthresh);
+
+ if (sensavg > (2.0 * darkthresh))
+ return I1PRO_RD_DARKNOTVALID;
+
+ return ev;
+}
+
+#ifdef DUMP_DARKM
+int ddumpdarkm = 0;
+#endif
+
+/* Take a dark reference measurement (combined parts 1 & 2) */
+i1pro_code i1pro_dark_measure(
+ i1pro *p,
+ double *absraw, /* Return array [-1 nraw] of absraw values */
+ int nummeas, /* Number of readings to take */
+ double *inttime, /* Integration time to use/used */
+ int gainmode /* Gain mode to use, 0 = normal, 1 = high */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ unsigned char *buf; /* Raw USB reading buffer */
+ unsigned int bsize;
+
+ bsize = m->nsen * 2 * nummeas;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro_dark_measure malloc %d bytes failed (8)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+
+ if ((ev = i1pro_dark_measure_1(p, nummeas, inttime, gainmode, buf, bsize)) != I1PRO_OK) {
+ free(buf);
+ return ev;
+ }
+
+ if ((ev = i1pro_dark_measure_2(p, absraw,
+ nummeas, *inttime, gainmode, buf, bsize)) != I1PRO_OK) {
+ free(buf);
+ return ev;
+ }
+ free(buf);
+
+#ifdef DUMP_DARKM
+ /* Dump raw dark readings to a file "i1pddump.txt" */
+ if (ddumpdarkm) {
+ int j;
+ FILE *fp;
+
+ if ((fp = fopen("i1pddump.txt", "a")) == NULL)
+ a1logw(p->log,"Unable to open debug file i1pddump.txt\n");
+ else {
+
+ fprintf(fp, "\nDark measure: nummeas %d, inttime %f, gainmode %d, darkcells %f\n",nummeas,*inttime,gainmode, absraw[-1]);
+ fprintf(fp,"\t\t\t{ ");
+ for (j = 0; j < (m->nraw-1); j++)
+ fprintf(fp, "%f, ",absraw[j]);
+ fprintf(fp, "%f },\n",absraw[j]);
+ fclose(fp);
+ }
+ }
+#endif
+
+ return ev;
+}
+
+
+/* Take a white reference measurement */
+/* (Subtracts black and processes into wavelenths) */
+i1pro_code i1pro_whitemeasure(
+ i1pro *p,
+ double *abswav0, /* Return array [nwav[0]] of abswav values (may be NULL) */
+ double *abswav1, /* Return array [nwav[1]] of abswav values (if hr_init, may be NULL) */
+ double *absraw, /* Return array [-1 nraw] of absraw values */
+ double *optscale, /* Factor to scale gain/int time by to make optimal (may be NULL) */
+ int nummeas, /* Number of readings to take */
+ double *inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ double targoscale, /* Optimal reading scale factor */
+ int ltocmode /* 1 = Lamp turn on compensation mode */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ unsigned char *buf; /* Raw USB reading buffer */
+ unsigned int bsize;
+ double **multimes; /* Multiple measurement results */
+ double darkthresh; /* Consitency threshold scale limit */
+ int rv;
+
+ a1logd(p->log,3,"i1pro_whitemeasure called \n");
+
+ darkthresh = m->sens_dark + *inttime * 900.0; /* Default */
+ if (gainmode)
+ darkthresh *= m->highgain;
+
+ if (nummeas <= 0)
+ return I1PRO_INT_ZEROMEASURES;
+
+ /* Allocate temporaries up front to avoid delay between trigger and read */
+ bsize = m->nsen * 2 * nummeas;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro_whitemeasure malloc %d bytes failed (10)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+ multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);
+
+ a1logd(p->log,3,"Triggering measurement cycle, nummeas %d, inttime %f, gainmode %d\n",
+ nummeas, *inttime, gainmode);
+
+ if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p_cal)) != I1PRO_OK) {
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+ a1logd(p->log,4,"Gathering readings\n");
+
+ if ((ev = i1pro_readmeasurement(p, nummeas, 0, buf, bsize, NULL, i1p_cal)) != I1PRO_OK) {
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nummeas, *inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ return ev;
+ }
+
+#ifdef PLOT_DEBUG
+ printf("Dark data:\n");
+ plot_raw(s->dark_data);
+#endif
+
+ /* Subtract the black level */
+ i1pro_sub_absraw(p, nummeas, *inttime, gainmode, multimes, s->dark_data);
+
+ /* Convert linearised white value into output wavelength white reference */
+ ev = i1pro_whitemeasure_3(p, abswav0, abswav1, absraw, optscale, nummeas,
+ *inttime, gainmode, targoscale, multimes, darkthresh);
+
+ free(buf);
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+
+ return ev;
+}
+
+/* Process a single raw white reference measurement */
+/* (Subtracts black and processes into wavelenths) */
+/* Used for restoring calibration from the EEProm */
+i1pro_code i1pro_whitemeasure_buf(
+ i1pro *p,
+ double *abswav0, /* Return array [nwav[0]] of abswav values (may be NULL) */
+ double *abswav1, /* Return array [nwav[1]] of abswav values (if hr_init, may be NULL) */
+ double *absraw, /* Return array [-1 nraw] of absraw values */
+ double inttime, /* Integration time to used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ unsigned char *buf /* Raw buffer */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ double *meas; /* Multiple measurement results */
+ double darkthresh; /* Consitency threshold scale limit */
+
+ a1logd(p->log,3,"i1pro_whitemeasure_buf called \n");
+
+ meas = dvector(-1, m->nraw-1);
+
+ darkthresh = m->sens_dark + inttime * 900.0; /* Default */
+ if (gainmode)
+ darkthresh *= m->highgain;
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, &meas, buf, 1, inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ return ev;
+ }
+
+ /* Subtract the black level */
+ i1pro_sub_absraw(p, 1, inttime, gainmode, &meas, s->dark_data);
+
+ /* Convert linearised white value into output wavelength white reference */
+ ev = i1pro_whitemeasure_3(p, abswav0, abswav1, absraw, NULL, 1, inttime, gainmode,
+ 0.0, &meas, darkthresh);
+
+ free_dvector(meas, -1, m->nraw-1);
+
+ return ev;
+}
+
+/* Take a white reference measurement - part 3 */
+/* Average, check, and convert to output wavelengths */
+i1pro_code i1pro_whitemeasure_3(
+ i1pro *p,
+ double *abswav0, /* Return array [nwav[0]] of abswav values (may be NULL) */
+ double *abswav1, /* Return array [nwav[1]] of abswav values (if hr_init, may be NULL) */
+ double *absraw, /* Return array [-1 nraw] of absraw values */
+ double *optscale, /* Factor to scale gain/int time by to make optimal (may be NULL) */
+ int nummeas, /* Number of readings to take */
+ double inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ double targoscale, /* Optimal reading scale factor */
+ double **multimes, /* Multiple measurement results */
+ double darkthresh /* Raw dark threshold */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ double highest; /* Highest of sensor readings */
+ double sensavg; /* Overall average of sensor readings */
+ double satthresh; /* Saturation threshold */
+ double opttarget; /* Optimal sensor target */
+ int rv;
+
+ a1logd(p->log,3,"i1pro_whitemeasure_3 called \n");
+
+ if (gainmode == 0)
+ satthresh = m->sens_sat0;
+ else
+ satthresh = m->sens_sat1;
+ satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);
+
+ darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);
+
+ /* Average a set of measurements into one. */
+ /* Return zero if readings are consistent and not saturated. */
+ /* Return nz with bit 1 set if the readings are not consistent */
+ /* Return nz with bit 2 set if the readings are saturated */
+ /* Return the highest individual element. */
+ /* Return the overall average. */
+ rv = i1pro_average_multimeas(p, absraw, multimes, nummeas, &highest, &sensavg,
+ satthresh, darkthresh);
+#ifdef PLOT_DEBUG
+ printf("Average absolute sensor readings, average = %f, satthresh %f:\n",sensavg, satthresh);
+ plot_raw(absraw);
+#endif
+
+#ifndef IGNORE_WHITE_INCONS
+ if (rv & 1) {
+ return I1PRO_RD_WHITEREADINCONS;
+ }
+#endif /* IGNORE_WHITE_INCONS */
+
+ if (rv & 2) {
+ return I1PRO_RD_SENSORSATURATED;
+ }
+
+ /* Convert an absraw array from raw wavelengths to output wavelenths */
+ if (abswav0 != NULL) {
+ i1pro_absraw_to_abswav(p, 0, s->reflective, 1, &abswav0, &absraw);
+
+#ifdef PLOT_DEBUG
+ printf("Converted to wavelengths std res:\n");
+ plot_wav(m, 0, abswav0);
+#endif
+ }
+
+#ifdef HIGH_RES
+ if (abswav1 != NULL && m->hr_inited) {
+ i1pro_absraw_to_abswav(p, 1, s->reflective, 1, &abswav1, &absraw);
+
+#ifdef PLOT_DEBUG
+ printf("Converted to wavelengths high res:\n");
+ plot_wav(m, 1, abswav1);
+#endif
+ }
+#endif /* HIGH_RES */
+
+ if (optscale != NULL) {
+ double lhighest = highest;
+
+ if (lhighest < 1.0)
+ lhighest = 1.0;
+
+ /* Compute correction factor to make sensor optimal */
+ opttarget = i1pro_raw_to_absraw(p, (double)m->sens_target, inttime, gainmode);
+ opttarget *= targoscale;
+
+
+ a1logd(p->log,3,"Optimal target = %f, amount to scale = %f\n",opttarget, opttarget/lhighest);
+
+ *optscale = opttarget/lhighest;
+ }
+
+ return ev;
+}
+
+/* Take a wavelength reference measurement */
+/* (Measure and subtracts black and convert to absraw) */
+i1pro_code i1pro2_wl_measure(
+ i1pro *p,
+ double *absraw, /* Return array [-1 nraw] of absraw values */
+ double *optscale, /* Factor to scale gain/int time by to make optimal (may be NULL) */
+ double *inttime, /* Integration time to use/used */
+ double targoscale /* Optimal reading scale factor */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ int nummeas = 1; /* Number of measurements to take */
+ int gainmode = 0; /* Gain mode to use, 0 = normal, 1 = high */
+ unsigned char *buf; /* Raw USB reading buffer */
+ unsigned int bsize;
+ double *dark; /* Dark reading */
+ double **multimes; /* Measurement results */
+ double darkthresh; /* Consitency threshold scale limit/reading dark cell values */
+ double highest; /* Highest of sensor readings */
+ double sensavg; /* Overall average of sensor readings */
+ double satthresh; /* Saturation threshold */
+ double opttarget; /* Optimal sensor target */
+ int rv;
+
+ a1logd(p->log,3,"i1pro2_wl_measure called \n");
+
+ /* Allocate temporaries up front to avoid delay between trigger and read */
+ bsize = m->nsen * 2;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro2_wl_measure malloc %d bytes failed (10)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+
+ /* Do a dark reading at our integration time */
+ dark = dvector(-1, m->nraw-1);
+ multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);
+
+ if ((ev = i1pro_dark_measure(p, dark, nummeas, inttime, gainmode)) != I1PRO_OK) {
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free_dvector(dark, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+#ifdef PLOT_DEBUG
+ printf("Absraw dark data:\n");
+ plot_raw(dark);
+#endif
+
+ a1logd(p->log,3,"Triggering wl measurement cycle, inttime %f\n", *inttime);
+
+ if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p2_wl_cal)) != I1PRO_OK) {
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free_dvector(dark, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+ a1logd(p->log,4,"Gathering readings\n");
+
+ if ((ev = i1pro_readmeasurement(p, nummeas, 0, buf, bsize, NULL, i1p2_wl_cal)) != I1PRO_OK) {
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free_dvector(dark, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nummeas, *inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ return ev;
+ }
+
+ /* Convert satthresh and darkthresh/dark_cell values to abs */
+ if (gainmode == 0)
+ satthresh = m->sens_sat0;
+ else
+ satthresh = m->sens_sat1;
+ satthresh = i1pro_raw_to_absraw(p, satthresh, *inttime, gainmode);
+ darkthresh = i1pro_raw_to_absraw(p, darkthresh, *inttime, gainmode);
+
+#ifdef PLOT_DEBUG
+ printf("Absraw WL data:\n");
+ plot_raw(multimes[0]);
+#endif
+
+ /* Subtract the black level */
+ i1pro_sub_absraw(p, nummeas, *inttime, gainmode, multimes, dark);
+
+#ifdef PLOT_DEBUG
+ printf("Absraw WL - black data:\n");
+ plot_raw(multimes[0]);
+#endif
+
+ /* Average a set of measurements into one. */
+ /* Return zero if readings are consistent and not saturated. */
+ /* Return nz with bit 1 set if the readings are not consistent */
+ /* Return nz with bit 2 set if the readings are saturated */
+ /* Return the highest individual element. */
+ /* Return the overall average. */
+ rv = i1pro_average_multimeas(p, absraw, multimes, 1, &highest, &sensavg,
+ satthresh, darkthresh);
+#ifdef PLOT_DEBUG
+ printf("Average absolute sensor readings, average = %f, satthresh %f, absraw WL result:\n",sensavg, satthresh);
+ plot_raw(absraw);
+#endif
+
+#ifndef IGNORE_WHITE_INCONS
+ if (rv & 1) {
+ return I1PRO_RD_WHITEREADINCONS;
+ }
+#endif /* IGNORE_WHITE_INCONS */
+
+ if (rv & 2) {
+ return I1PRO_RD_SENSORSATURATED;
+ }
+
+ if (optscale != NULL) {
+ double lhighest = highest;
+
+ if (lhighest < 1.0)
+ lhighest = 1.0;
+
+ /* Compute correction factor to make sensor optimal */
+ opttarget = i1pro_raw_to_absraw(p, (double)m->sens_target, *inttime, gainmode);
+ opttarget *= targoscale;
+
+
+ a1logd(p->log,3,"Optimal target = %f, amount to scale = %f\n",opttarget, opttarget/lhighest);
+
+ *optscale = opttarget/lhighest;
+ }
+
+ free(buf);
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free_dvector(dark, -1, m->nraw-1);
+
+ return ev;
+}
+
+/* Take a measurement reading using the current mode, part 1 */
+/* Converts to completely processed output readings. */
+/* (NOTE:- this can't be used for calibration, as it implements uv mode) */
+i1pro_code i1pro_read_patches_1(
+ i1pro *p,
+ int minnummeas, /* Minimum number of measurements to take */
+ int maxnummeas, /* Maximum number of measurements to allow for */
+ double *inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ int *nmeasuered, /* Number actually measured */
+ unsigned char *buf, /* Raw USB reading buffer */
+ unsigned int bsize
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ i1p_mmodif mmod = i1p_norm;
+ int rv = 0;
+
+ if (minnummeas <= 0)
+ return I1PRO_INT_ZEROMEASURES;
+ if (minnummeas > maxnummeas)
+ maxnummeas = minnummeas;
+
+ if (m->uv_en)
+ mmod = i1p2_UV;
+
+ a1logd(p->log,3,"Triggering & gathering cycle, minnummeas %d, inttime %f, gainmode %d\n",
+ minnummeas, *inttime, gainmode);
+
+ if ((ev = i1pro_trigger_one_measure(p, minnummeas, inttime, gainmode, mmod)) != I1PRO_OK) {
+ return ev;
+ }
+
+ if ((ev = i1pro_readmeasurement(p, minnummeas, m->c_measmodeflags & I1PRO_MMF_SCAN,
+ buf, bsize, nmeasuered, mmod)) != I1PRO_OK) {
+ return ev;
+ }
+
+ return ev;
+}
+
+/* Take a measurement reading using the current mode, part 2 */
+/* Converts to completely processed output readings. */
+i1pro_code i1pro_read_patches_2(
+ i1pro *p,
+ double *duration, /* Return flash duration */
+ double **specrd, /* Return array [numpatches][nwav] of spectral reading values */
+ int numpatches, /* Number of patches to return */
+ double inttime, /* Integration time to used */
+ int gainmode, /* Gain mode useed, 0 = normal, 1 = high */
+ int nmeasuered, /* Number actually measured */
+ unsigned char *buf, /* Raw USB reading buffer */
+ unsigned int bsize
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ double **multimes; /* Multiple measurement results [maxnummeas|nmeasuered][-1 nraw]*/
+ double **absraw; /* Linearsised absolute sensor raw values [numpatches][-1 nraw]*/
+ double satthresh; /* Saturation threshold */
+ double darkthresh; /* Dark threshold for consistency scaling limit */
+ int rv = 0;
+
+ if (duration != NULL)
+ *duration = 0.0; /* default value */
+
+ darkthresh = m->sens_dark + inttime * 900.0; /* Default */
+ if (gainmode)
+ darkthresh *= m->highgain;
+
+ /* Allocate temporaries */
+ multimes = dmatrix(0, nmeasuered-1, -1, m->nraw-1);
+ absraw = dmatrix(0, numpatches-1, -1, m->nraw-1);
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nmeasuered, inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ return ev;
+ }
+
+ /* Subtract the black level */
+ i1pro_sub_absraw(p, nmeasuered, inttime, gainmode, multimes, s->dark_data);
+
+#ifdef DUMP_SCANV
+ /* Dump raw scan readings to a file "i1pdump.txt" */
+ {
+ int i, j;
+ FILE *fp;
+
+ if ((fp = fopen("i1pdump.txt", "w")) == NULL)
+ a1logw(p->log,"Unable to open debug file i1pdump.txt\n");
+ else {
+ for (i = 0; i < nmeasuered; i++) {
+ fprintf(fp, "%d ",i);
+ for (j = 0; j < m->nraw; j++) {
+ fprintf(fp, "%f ",multimes[i][j]);
+ }
+ fprintf(fp,"\n");
+ }
+ fclose(fp);
+ }
+ }
+#endif
+ if (gainmode == 0)
+ satthresh = m->sens_sat0;
+ else
+ satthresh = m->sens_sat1;
+ satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);
+
+ darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);
+
+ if (!s->scan) {
+ if (numpatches != 1) {
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+ a1logd(p->log,2,"i1pro_read_patches_2 spot read failed because numpatches != 1\n");
+ return I1PRO_INT_WRONGPATCHES;
+ }
+
+ /* Average a set of measurements into one. */
+ /* Return zero if readings are consistent and not saturated. */
+ /* Return nz with bit 1 set if the readings are not consistent */
+ /* Return nz with bit 2 set if the readings are saturated */
+ /* Return the highest individual element. */
+ /* Return the overall average. */
+ rv = i1pro_average_multimeas(p, absraw[0], multimes, nmeasuered, NULL, NULL,
+ satthresh, darkthresh);
+ } else {
+ if (s->flash) {
+
+ if (numpatches != 1) {
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+ a1logd(p->log,2,"i1pro_read_patches_2 spot read failed because numpatches != 1\n");
+ return I1PRO_INT_WRONGPATCHES;
+ }
+ if ((ev = i1pro_extract_patches_flash(p, &rv, duration, absraw[0], multimes,
+ nmeasuered, inttime)) != I1PRO_OK) {
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+ a1logd(p->log,2,"i1pro_read_patches_2 spot read failed at i1pro_extract_patches_flash\n");
+ return ev;
+ }
+
+ } else {
+ a1logd(p->log,3,"Number of patches measured = %d\n",nmeasuered);
+
+ /* Recognise the required number of ref/trans patch locations, */
+ /* and average the measurements within each patch. */
+ if ((ev = i1pro_extract_patches_multimeas(p, &rv, absraw, numpatches, multimes,
+ nmeasuered, NULL, satthresh, inttime)) != I1PRO_OK) {
+ free_dmatrix(multimes, 0, nmeasuered-1, -1, m->nraw-1);
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ a1logd(p->log,2,"i1pro_read_patches_2 spot read failed at i1pro_extract_patches_multimeas\n");
+ return ev;
+ }
+ }
+ }
+
+ if (rv & 1) {
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ a1logd(p->log,3,"i1pro_read_patches_2 spot read failed with inconsistent readings\n");
+ return I1PRO_RD_READINCONS;
+ }
+
+ if (rv & 2) {
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ a1logd(p->log,3,"i1pro_read_patches_2 spot read failed with sensor saturated\n");
+ return I1PRO_RD_SENSORSATURATED;
+ }
+
+ /* Convert an absraw array from raw wavelengths to output wavelenths */
+ i1pro_absraw_to_abswav(p, m->highres, s->reflective, numpatches, specrd, absraw);
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+
+#ifdef APPEND_MEAN_EMMIS_VAL
+ /* Append averaged emission reading to file "i1pdump.txt" */
+ {
+ int i, j;
+ FILE *fp;
+
+ /* Create wavelegth label */
+ if ((fp = fopen("i1pdump.txt", "r")) == NULL) {
+ if ((fp = fopen("i1pdump.txt", "w")) == NULL)
+ a1logw(p->log,"Unable to reate debug file i1pdump.txt\n");
+ else {
+ for (j = 0; j < m->nwav[m->highres]; j++)
+ fprintf(fp,"%f ",XSPECT_WL(m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], j));
+ fprintf(fp,"\n");
+ fclose(fp);
+ }
+ }
+ if ((fp = fopen("i1pdump.txt", "a")) == NULL) {
+ a1logw(p->log,"Unable to open debug file i1pdump.txt\n");
+ else {
+ for (j = 0; j < m->nwav[m->highres]; j++)
+ fprintf(fp, "%f ",specrd[0][j] * m->emis_coef[j]);
+ fprintf(fp,"\n");
+ fclose(fp);
+ }
+ }
+#endif
+
+#ifdef PLOT_DEBUG
+ printf("Converted to wavelengths:\n");
+ plot_wav(m, m->highres, specrd[0]);
+#endif
+
+ /* Scale to the calibrated output values */
+ i1pro_scale_specrd(p, specrd, numpatches, specrd);
+
+#ifdef PLOT_DEBUG
+ printf("Calibrated measuerment spectra:\n");
+ plot_wav(m, m->highres, specrd[0]);
+#endif
+
+ return ev;
+}
+
+/* Take a measurement reading using the current mode, part 2a */
+/* Converts to completely processed output readings, */
+/* but don't average together or extract patches or flash. */
+/* (! Note that we aren't currently detecting saturation here!) */
+i1pro_code i1pro_read_patches_2a(
+ i1pro *p,
+ double **specrd, /* Return array [numpatches][nwav] of spectral reading values */
+ int numpatches, /* Number of patches measured and to return */
+ double inttime, /* Integration time to used */
+ int gainmode, /* Gain mode useed, 0 = normal, 1 = high */
+ unsigned char *buf, /* Raw USB reading buffer */
+ unsigned int bsize
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ double **absraw; /* Linearsised absolute sensor raw values [numpatches][-1 nraw]*/
+ double satthresh; /* Saturation threshold */
+ double darkthresh; /* Dark threshold for consistency scaling limit */
+
+ darkthresh = m->sens_dark + inttime * 900.0; /* Default */
+ if (gainmode)
+ darkthresh *= m->highgain;
+
+ /* Allocate temporaries */
+ absraw = dmatrix(0, numpatches-1, -1, m->nraw-1);
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, absraw, buf, numpatches, inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+ return ev;
+ }
+
+ /* Subtract the black level */
+ i1pro_sub_absraw(p, numpatches, inttime, gainmode, absraw, s->dark_data);
+
+ if (gainmode == 0)
+ satthresh = m->sens_sat0;
+ else
+ satthresh = m->sens_sat1;
+ satthresh = i1pro_raw_to_absraw(p, satthresh, inttime, gainmode);
+
+ darkthresh = i1pro_raw_to_absraw(p, darkthresh, inttime, gainmode);
+
+ a1logd(p->log,3,"Number of patches measured = %d\n",numpatches);
+
+ /* Convert an absraw array from raw wavelengths to output wavelenths */
+ i1pro_absraw_to_abswav(p, m->highres, s->reflective, numpatches, specrd, absraw);
+ free_dmatrix(absraw, 0, numpatches-1, -1, m->nraw-1);
+
+#ifdef PLOT_DEBUG
+ printf("Converted to wavelengths:\n");
+ plot_wav(m, m->highres, specrd[0]);
+#endif
+
+ /* Scale to the calibrated output values */
+ i1pro_scale_specrd(p, specrd, numpatches, specrd);
+
+#ifdef PLOT_DEBUG
+ printf("Calibrated measuerment spectra:\n");
+ plot_wav(m, m->highres, specrd[0]);
+#endif
+
+ return ev;
+}
+
+/* Take a measurement reading using the current mode (combined parts 1 & 2) */
+/* Converts to completely processed output readings. */
+/* (NOTE:- this can't be used for calibration, as it implements uv mode) */
+i1pro_code i1pro_read_patches(
+ i1pro *p,
+ double *duration, /* Return flash duration */
+ double **specrd, /* Return array [numpatches][nwav] of spectral reading values */
+ int numpatches, /* Number of patches to return */
+ int minnummeas, /* Minimum number of measurements to take */
+ int maxnummeas, /* Maximum number of measurements to allow for */
+ double *inttime, /* Integration time to use/used */
+ int gainmode /* Gain mode to use, 0 = normal, 1 = high */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ unsigned char *buf; /* Raw USB reading buffer */
+ unsigned int bsize;
+ int nmeasuered; /* Number actually measured */
+ int rv = 0;
+
+ if (minnummeas <= 0)
+ return I1PRO_INT_ZEROMEASURES;
+ if (minnummeas > maxnummeas)
+ maxnummeas = minnummeas;
+
+ /* Allocate temporaries */
+ bsize = m->nsen * 2 * maxnummeas;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro_read_patches malloc %d bytes failed (11)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+
+ /* Trigger measure and gather raw readings */
+ if ((ev = i1pro_read_patches_1(p, minnummeas, maxnummeas, inttime, gainmode,
+ &nmeasuered, buf, bsize)) != I1PRO_OK) {
+ free(buf);
+ return ev;
+ }
+
+ /* Process the raw readings */
+ if ((ev = i1pro_read_patches_2(p, duration, specrd, numpatches, *inttime, gainmode,
+ nmeasuered, buf, bsize)) != I1PRO_OK) {
+ free(buf);
+ return ev;
+ }
+ free(buf);
+ return ev;
+}
+
+/* Take a measurement reading using the current mode (combined parts 1 & 2a) */
+/* Converts to completely processed output readings, without averaging or extracting */
+/* sample patches. */
+/* (NOTE:- this can't be used for calibration, as it implements uv mode) */
+i1pro_code i1pro_read_patches_all(
+ i1pro *p,
+ double **specrd, /* Return array [numpatches][nwav] of spectral reading values */
+ int numpatches, /* Number of sample to measure */
+ double *inttime, /* Integration time to use/used */
+ int gainmode /* Gain mode to use, 0 = normal, 1 = high */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ unsigned char *buf; /* Raw USB reading buffer */
+ unsigned int bsize;
+ int rv = 0;
+
+ bsize = m->nsen * 2 * numpatches;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro_read_patches malloc %d bytes failed (11)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+
+ /* Trigger measure and gather raw readings */
+ if ((ev = i1pro_read_patches_1(p, numpatches, numpatches, inttime, gainmode,
+ NULL, buf, bsize)) != I1PRO_OK) {
+ free(buf);
+ return ev;
+ }
+
+ /* Process the raw readings without averaging or extraction */
+ if ((ev = i1pro_read_patches_2a(p, specrd, numpatches, *inttime, gainmode,
+ buf, bsize)) != I1PRO_OK) {
+ free(buf);
+ return ev;
+ }
+ free(buf);
+ return ev;
+}
+
+/* Take a trial measurement reading using the current mode. */
+/* Used to determine if sensor is saturated, or not optimal */
+/* in adaptive emission mode. */
+i1pro_code i1pro_trialmeasure(
+ i1pro *p,
+ int *saturated, /* Return nz if sensor is saturated */
+ double *optscale, /* Factor to scale gain/int time by to make optimal (may be NULL) */
+ int nummeas, /* Number of readings to take */
+ double *inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ double targoscale /* Optimal reading scale factor */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ unsigned char *buf; /* Raw USB reading buffer */
+ unsigned int bsize;
+ double **multimes; /* Multiple measurement results */
+ double *absraw; /* Linearsised absolute sensor raw values */
+ int nmeasuered; /* Number actually measured */
+ double highest; /* Highest of sensor readings */
+ double sensavg; /* Overall average of sensor readings */
+ double satthresh; /* Saturation threshold */
+ double darkthresh; /* Dark threshold */
+ double opttarget; /* Optimal sensor target */
+ int rv;
+
+ if (nummeas <= 0)
+ return I1PRO_INT_ZEROMEASURES;
+
+ darkthresh = m->sens_dark + *inttime * 900.0;
+ if (gainmode)
+ darkthresh *= m->highgain;
+
+ /* Allocate up front to avoid delay between trigger and read */
+ bsize = m->nsen * 2 * nummeas;
+ if ((buf = (unsigned char *)malloc(sizeof(unsigned char) * bsize)) == NULL) {
+ a1logd(p->log,1,"i1pro_trialmeasure malloc %d bytes failed (12)\n",bsize);
+ return I1PRO_INT_MALLOC;
+ }
+ multimes = dmatrix(0, nummeas-1, -1, m->nraw-1);
+ absraw = dvector(-1, m->nraw-1);
+
+ a1logd(p->log,3,"Triggering measurement cycle, nummeas %d, inttime %f, gainmode %d\n",
+ nummeas, *inttime, gainmode);
+
+ if ((ev = i1pro_trigger_one_measure(p, nummeas, inttime, gainmode, i1p_cal)) != I1PRO_OK) {
+ free_dvector(absraw, -1, m->nraw-1);
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+ a1logd(p->log,4,"Gathering readings\n");
+ if ((ev = i1pro_readmeasurement(p, nummeas, m->c_measmodeflags & I1PRO_MMF_SCAN,
+ buf, bsize, &nmeasuered, i1p_cal)) != I1PRO_OK) {
+ free_dvector(absraw, -1, m->nraw-1);
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free(buf);
+ return ev;
+ }
+
+ /* Take a buffer full of raw readings, and convert them to */
+ /* absolute linearised sensor values. */
+ if ((ev = i1pro_sens_to_absraw(p, multimes, buf, nmeasuered, *inttime, gainmode, &darkthresh))
+ != I1PRO_OK) {
+ return ev;
+ }
+
+ /* Compute dark subtraction for this trial's parameters */
+ if ((ev = i1pro_interp_dark(p, s->dark_data,
+ s->inttime, s->gainmode)) != I1PRO_OK) {
+ free_dvector(absraw, -1, m->nraw-1);
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free(buf);
+ a1logd(p->log,2,"i1pro_trialmeasure interplate dark ref failed\n");
+ return ev;
+ }
+
+ /* Subtract the black level */
+ i1pro_sub_absraw(p, nummeas, *inttime, gainmode, multimes, s->dark_data);
+
+ if (gainmode == 0)
+ satthresh = m->sens_sat0;
+ else
+ satthresh = m->sens_sat1;
+ satthresh = i1pro_raw_to_absraw(p, satthresh, *inttime, gainmode);
+
+ darkthresh = i1pro_raw_to_absraw(p, darkthresh, *inttime, gainmode);
+
+ /* Average a set of measurements into one. */
+ /* Return zero if readings are consistent and not saturated. */
+ /* Return nz with bit 1 set if the readings are not consistent */
+ /* Return nz with bit 2 set if the readings are saturated */
+ /* Return the highest individual element. */
+ /* Return the overall average. */
+ rv = i1pro_average_multimeas(p, absraw, multimes, nmeasuered, &highest, &sensavg,
+ satthresh, darkthresh);
+#ifdef PLOT_DEBUG
+ printf("Average absolute sensor readings, average = %f, satthresh %f:\n",sensavg, satthresh);
+ plot_raw(absraw);
+#endif
+
+ if (saturated != NULL) {
+ *saturated = 0;
+ if (rv & 2)
+ *saturated = 1;
+ }
+
+ /* Compute correction factor to make sensor optimal */
+ opttarget = (double)m->sens_target * targoscale;
+ opttarget = i1pro_raw_to_absraw(p, opttarget, *inttime, gainmode);
+
+ if (optscale != NULL) {
+ double lhighest = highest;
+
+ if (lhighest < 1.0)
+ lhighest = 1.0;
+
+ *optscale = opttarget/lhighest;
+ }
+
+ free_dmatrix(multimes, 0, nummeas-1, -1, m->nraw-1);
+ free_dvector(absraw, -1, m->nraw-1);
+ free(buf);
+
+ return ev;
+}
+
+/* Trigger a single measurement cycle. This could be a dark calibration, */
+/* a calibration, or a real measurement. This is used to create the */
+/* higher level "calibrate" and "take reading" functions. */
+/* The setup for the operation is in the current mode state. */
+/* Call i1pro_readmeasurement() to collect the results */
+i1pro_code
+i1pro_trigger_one_measure(
+ i1pro *p,
+ int nummeas, /* Minimum number of measurements to make */
+ double *inttime, /* Integration time to use/used */
+ int gainmode, /* Gain mode to use, 0 = normal, 1 = high */
+ i1p_mmodif mmodif /* Measurement modifier enum */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ unsigned int timssinceoff; /* time in msec since lamp turned off */
+ double dintclocks;
+ int intclocks; /* Number of integration clocks */
+ double dlampclocks;
+ int lampclocks; /* Number of lamp turn on sub-clocks */
+ int measmodeflags; /* Measurement mode command flags */
+ int measmodeflags2; /* Rev E Measurement mode command flags */
+
+ /* The Rev E measure mode has it's own settings */
+ if (p->itype == instI1Pro2) {
+ m->intclkp = m->intclkp2; /* From i1pro2_getmeaschar() ? */
+ m->subclkdiv = m->subclkdiv2;
+ m->subtmode = 0;
+
+ } else {
+ /* Set any special hardware up for this sort of read */
+ if (*inttime != m->c_inttime) { /* integration time is different */
+ int mcmode, maxmcmode;
+ int intclkusec;
+ int subtmodeflags;
+
+ /* Setting for fwrev < 301 */
+ /* (This is what getmcmode() returns for mcmode = 1 on fwrev >= 301) */
+ m->intclkp = 68.0e-6;
+ m->subclkdiv = 130;
+ m->subtmode = 0;
+
+ if (m->fwrev >= 301) { /* Special hardware in latter versions of instrument */
+
+#ifdef DEBUG
+ /* Show all the available clock modes */
+ for (mcmode = 1;; mcmode++) {
+ int rmcmode, subclkdiv;
+
+ if ((ev = i1pro_setmcmode(p, mcmode)) != I1PRO_OK)
+ break;
+
+ if ((ev = i1pro_getmcmode(p, &maxmcmode, &rmcmode, &subclkdiv,
+ &intclkusec, &subtmodeflags) ) != I1PRO_OK)
+ break;
+
+ fprintf(stderr,"getcmode %d: maxcmode %d, mcmode %d, subclkdif %d, intclkusec %d, subtmodeflags 0x%x\n",mcmode,maxmcmode,rmcmode,subclkdiv,intclkusec,subtmodeflags);
+ if (mcmode >= maxmcmode)
+ break;
+ }
+#endif
+ /* Configure a clock mode that gives us an optimal integration time ? */
+ for (mcmode = 1;; mcmode++) {
+ if ((ev = i1pro_setmcmode(p, mcmode)) != I1PRO_OK)
+ return ev;
+
+ if ((ev = i1pro_getmcmode(p, &maxmcmode, &mcmode, &m->subclkdiv,
+ &intclkusec, &subtmodeflags) ) != I1PRO_OK)
+ return ev;
+
+ if ((*inttime/(intclkusec * 1e-6)) > 65535.0) {
+ return I1PRO_INT_INTTOOBIG;
+ }
+
+ if (*inttime >= (intclkusec * m->subclkdiv * 1e-6 * 0.99))
+ break; /* Setting is optimal */
+
+ /* We need to go around again */
+ if (mcmode >= maxmcmode) {
+ return I1PRO_INT_INTTOOSMALL;
+ }
+ }
+ m->c_mcmode = mcmode;
+ m->intclkp = intclkusec * 1e-6;
+ a1logd(p->log,3,"Switched to perfect mode, subtmode flag = 0x%x, intclk = %f Mhz\n",subtmodeflags & 0x01, 1.0/intclkusec);
+ if (subtmodeflags & 0x01)
+ m->subtmode = 1; /* Last reading subtract mode */
+ }
+ }
+ }
+ a1logd(p->log,3,"Integration clock period = %f ussec\n",m->intclkp * 1e6);
+
+ /* Compute integration clocks */
+ dintclocks = floor(*inttime/m->intclkp + 0.5);
+ if (p->itype == instI1Pro2) {
+ if (dintclocks > 4294967296.0) /* This is probably not the actual limit */
+ return I1PRO_INT_INTTOOBIG;
+ } else {
+ if (dintclocks > 65535.0)
+ return I1PRO_INT_INTTOOBIG;
+ }
+ intclocks = (int)dintclocks;
+ *inttime = (double)intclocks * m->intclkp; /* Quantized integration time */
+
+ if (s->reflective && (mmodif & 0x10)) {
+ dlampclocks = floor(s->lamptime/(m->subclkdiv * m->intclkp) + 0.5);
+ if (dlampclocks > 256.0) /* Clip - not sure why. Silly value anyway */
+ dlampclocks = 256.0;
+ lampclocks = (int)dlampclocks;
+ s->lamptime = dlampclocks * m->subclkdiv * m->intclkp; /* Quantized lamp time */
+ } else {
+ dlampclocks = 0.0;
+ lampclocks = 0;
+ }
+
+ if (nummeas > 65535)
+ nummeas = 65535; /* Or should we error ? */
+
+ /* Create measurement mode flag values for this operation for both */
+ /* legacy and Rev E mode. Other code will examine legacy mode flags */
+ measmodeflags = 0;
+ if (s->scan && !(mmodif & 0x20)) /* Never scan on a calibration */
+ measmodeflags |= I1PRO_MMF_SCAN;
+ if (!s->reflective || !(mmodif & 0x10))
+ measmodeflags |= I1PRO_MMF_NOLAMP; /* No lamp if not reflective or dark measure */
+ if (gainmode == 0)
+ measmodeflags |= I1PRO_MMF_LOWGAIN; /* Normal gain mode */
+
+ if (p->itype == instI1Pro2) {
+ measmodeflags2 = 0;
+ if (s->scan && !(mmodif & 0x20)) /* Never scan on a calibration */
+ measmodeflags2 |= I1PRO2_MMF_SCAN;
+
+ if (mmodif == i1p2_UV)
+ measmodeflags2 |= I1PRO2_MMF_UV_LED; /* UV LED illumination measurement */
+ else if (mmodif == i1p2_wl_cal)
+ measmodeflags2 |= I1PRO2_MMF_WL_LED; /* Wavelegth illumination cal */
+ else if (s->reflective && (mmodif & 0x10))
+ measmodeflags2 |= I1PRO2_MMF_LAMP; /* lamp if reflective and mmodif possible */
+
+ if (gainmode != 0)
+ return I1PRO_INT_NO_HIGH_GAIN;
+ }
+
+ a1logd(p->log,2,"i1pro: Int time %f msec, delay %f msec, no readings %d, expect %f msec\n",
+ *inttime * 1000.0,
+ ((measmodeflags & I1PRO_MMF_NOLAMP) ? 0.0 : s->lamptime) * 1000.0,
+ nummeas,
+ (nummeas * *inttime + ((measmodeflags & I1PRO_MMF_NOLAMP) ? 0.0 : s->lamptime)) * 1000.0);
+
+ /* Do a setmeasparams */
+#ifdef NEVER
+ if (intclocks != m->c_intclocks /* If any parameters have changed */
+ || lampclocks != m->c_lampclocks
+ || nummeas != m->c_nummeas
+ || measmodeflags != m->c_measmodeflags
+ || measmodeflags2 != m->c_measmodeflags2)
+#endif /* NEVER */
+ {
+
+ if (p->itype != instI1Pro2) { /* Rev E sets the params in the measure command */
+ /* Set the hardware for measurement */
+ if ((ev = i1pro_setmeasparams(p, intclocks, lampclocks, nummeas, measmodeflags)) != I1PRO_OK)
+ return ev;
+ } else {
+ a1logd(p->log,2,"\ni1pro: SetMeasureParam2 %d, %d, %d, 0x%04x @ %d msec\n",
+ intclocks, lampclocks, nummeas, measmodeflags2,
+ msec_time() - m->msec);
+ }
+
+ m->c_intclocks = intclocks;
+ m->c_lampclocks = lampclocks;
+ m->c_nummeas = nummeas;
+ m->c_measmodeflags = measmodeflags;
+ m->c_measmodeflags2 = measmodeflags2;
+
+ m->c_inttime = *inttime; /* Special harware is configured */
+ m->c_lamptime = s->lamptime;
+ }
+
+ /* If the lamp needs to be off, make sure at least 1.5 seconds */
+ /* have elapsed since it was last on, to make sure it's dark. */
+ if ((measmodeflags & I1PRO_MMF_NOLAMP)
+ && (timssinceoff = (msec_time() - m->llamponoff)) < LAMP_OFF_TIME) {
+ a1logd(p->log,3,"Sleep %d msec for lamp cooldown\n",LAMP_OFF_TIME - timssinceoff);
+ msec_sleep(LAMP_OFF_TIME - timssinceoff); /* Make sure time adds up to 1.5 seconds */
+ }
+
+ /* Trigger a measurement */
+ if (p->itype != instI1Pro2) {
+ if ((ev = i1pro_triggermeasure(p, TRIG_DELAY)) != I1PRO_OK)
+ return ev;
+ } else {
+ if ((ev = i1pro2_triggermeasure(p, TRIG_DELAY)) != I1PRO_OK)
+ return ev;
+ }
+
+ return ev;
+}
+
+/* ============================================================ */
+/* Big endian wire format conversion routines */
+
+/* Take an int, and convert it into a byte buffer big endian */
+static void int2buf(unsigned char *buf, int inv) {
+ buf[0] = (inv >> 24) & 0xff;
+ buf[1] = (inv >> 16) & 0xff;
+ buf[2] = (inv >> 8) & 0xff;
+ buf[3] = (inv >> 0) & 0xff;
+}
+
+/* Take a short, and convert it into a byte buffer big endian */
+static void short2buf(unsigned char *buf, int inv) {
+ buf[0] = (inv >> 8) & 0xff;
+ buf[1] = (inv >> 0) & 0xff;
+}
+
+/* Take a word sized buffer, and convert it to an int */
+static int buf2int(unsigned char *buf) {
+ int val;
+ val = buf[0]; /* Hmm. should this be sign extended ?? */
+ val = ((val << 8) + (0xff & buf[1]));
+ val = ((val << 8) + (0xff & buf[2]));
+ val = ((val << 8) + (0xff & buf[3]));
+ return val;
+}
+
+/* Take a short sized buffer, and convert it to an int */
+static int buf2short(unsigned char *buf) {
+ int val;
+ val = *((signed char *)buf); /* Sign extend */
+ val = ((val << 8) + (0xff & buf[1]));
+ return val;
+}
+
+/* Take a unsigned short sized buffer, and convert it to an int */
+static int buf2ushort(unsigned char *buf) {
+ int val;
+ val = (0xff & buf[0]);
+ val = ((val << 8) + (0xff & buf[1]));
+ return val;
+}
+
+/* ============================================================ */
+/* lower level reading processing and computation */
+
+/* Take a buffer full of sensor readings, and convert them to */
+/* absolute raw values. Linearise if Rev A..D */
+/* If RevE, fill in the [-1] value with the shielded cell values */
+/* Note the rev E darkthresh returned has NOT been converted to an absolute raw value */
+i1pro_code i1pro_sens_to_absraw(
+ i1pro *p,
+ double **absraw, /* Array of [nummeas][-1 nraw] value to return */
+ unsigned char *buf, /* Raw measurement data must be nsen * nummeas */
+ int nummeas, /* Return number of readings measured */
+ double inttime, /* Integration time used */
+ int gainmode, /* Gain mode, 0 = normal, 1 = high */
+ double *pdarkthresh /* Return a raw dark threshold value (Rev E) */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j, k;
+ unsigned char *bp;
+ unsigned int maxpve = m->maxpve; /* maximum +ve sensor value + 1 */
+ double avlastv = 0.0;
+ double darkthresh = 0.0; /* Rev E calculated values */
+ double ndarkthresh = 0.0;
+ double gain;
+ int npoly; /* Number of linearisation coefficients */
+ double *polys; /* the coeficients */
+ double scale; /* Absolute scale value */
+ int sskip = 0; /* Bytes to skip at start */
+ int eskip = 0; /* Bytes to skip at end */
+
+ if (gainmode) {
+ gain = m->highgain;
+ npoly = m->nlin1;
+ polys = m->lin1;
+ } else {
+ gain = 1.0;
+ npoly = m->nlin0;
+ polys = m->lin0;
+ }
+ scale = 1.0/(inttime * gain);
+
+ /* Now process the buffer values */
+ if (m->nsen > m->nraw) { /* It's a Rev E, so we have extra values, */
+ /* and don't linearize here. */
+ sskip = 6 * 2; /* 6 dark reading values */
+ eskip = 0 * 2; /* none to skip at end */
+
+ if ((sskip + m->nraw * 2 + eskip) != (m->nsen * 2)) {
+ a1loge(p->log,1,"i1pro Rev E - sskip %d + nraw %d + eskip %d != nsen %d\n"
+ ,sskip, m->nraw * 2, eskip, m->nsen * 2);
+ return I1PRO_INT_ASSERT;
+ }
+
+ for (bp = buf, i = 0; i < nummeas; i++, bp += eskip) {
+ unsigned int rval;
+ double fval;
+
+ /* The first 6 readings (xraw from i1pro2_getmeaschar()) are shielded cells, */
+ /* and we use them as an estimate of the dark reading consistency, as well as for */
+ /* compensating the dark level calibration for any temperature changes. */
+
+ /* raw average of all measurement shielded cell values */
+ for (k = 0; k < 6; k++) {
+ darkthresh += (double)buf2ushort(bp + k * 2);
+ ndarkthresh++;
+ }
+
+ /* absraw of shielded cells per reading */
+ absraw[i][-1] = 0.0;
+ for (k = 0; k < 6; k++) {
+ rval = buf2ushort(bp + k * 2);
+ fval = (double)(int)rval;
+
+ /* And scale to be an absolute sensor reading */
+ absraw[i][-1] += fval * scale;
+ }
+ absraw[i][-1] /= 6.0;
+
+ for (bp += sskip, j = 0; j < m->nraw; j++, bp += 2) {
+ rval = buf2ushort(bp);
+ a1logd(p->log,9,"% 3d:rval 0x%x, ",j, rval);
+ a1logd(p->log,9,"srval 0x%x, ",rval);
+ fval = (double)(int)rval;
+ a1logd(p->log,9,"fval %.0f, ",fval);
+
+ /* And scale to be an absolute sensor reading */
+ absraw[i][j] = fval * scale;
+ a1logd(p->log,9,"absval %.1f\n",fval * scale);
+ }
+ }
+ darkthresh /= ndarkthresh;
+ if (pdarkthresh != NULL)
+ *pdarkthresh = darkthresh;
+ a1logd(p->log,3,"i1pro_sens_to_absraw: Dark threshold = %f\n",darkthresh);
+
+ } else {
+ /* if subtmode is set, compute the average last reading raw value. */
+ /* Could this be some sort of temperature compensation offset ??? */
+ /* (Rev A produces a value that is quite different to a sensor value, */
+ /* ie. 1285 = 0x0505, while RevD and RevE in legacy mode have a value of 0 */
+ /* I've not seen anything actually use subtmode - maybe this is Rev B only ?) */
+ /* The 0 band seens to contain values similar to band 1, so it's not clear */
+ /* why the manufacturers driver appears to be discarding it ? */
+
+ /* (Not sure if it's reasonable to extend the sign and then do this */
+ /* computation, or whether it makes any difference, since I've never */
+ /* seen this mode triggered. */
+ if (m->subtmode) {
+ for (bp = buf + 254, i = 0; i < nummeas; i++, bp += (m->nsen * 2)) {
+ unsigned int lastv;
+ lastv = buf2ushort(bp);
+ if (lastv >= maxpve) {
+ lastv -= 0x00010000; /* Convert to -ve */
+ }
+ avlastv += (double)lastv;
+ }
+ avlastv /= (double)nummeas;
+ a1logd(p->log,3,"subtmode got avlastv = %f\n",avlastv);
+ }
+
+ for (bp = buf, i = 0; i < nummeas; i++) {
+ absraw[i][-1] = 1.0; /* Not used in RevA-D */
+
+ for (j = 0; j < 128; j++, bp += 2) {
+ unsigned int rval;
+ double fval, lval;
+
+ rval = buf2ushort(bp);
+ a1logd(p->log,9,"% 3d:rval 0x%x, ",j, rval);
+ if (rval >= maxpve)
+ rval -= 0x00010000; /* Convert to -ve */
+ a1logd(p->log,9,"srval 0x%x, ",rval);
+ fval = (double)(int)rval;
+ a1logd(p->log,9,"fval %.0f, ",fval);
+ fval -= avlastv;
+ a1logd(p->log,9,"fval-av %.0f, ",fval);
+
+#ifdef ENABLE_NONLINCOR
+ /* Linearise */
+ for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--)
+ lval = lval * fval + polys[k];
+#else
+ lval = fval;
+#endif
+ a1logd(p->log,9,"lval %.1f, ",lval);
+
+ /* And scale to be an absolute sensor reading */
+ absraw[i][j] = lval * scale;
+ a1logd(p->log,9,"absval %.1f\n",lval * scale);
+ // a1logd(p->log,3,"Meas %d band %d raw = %f\n",i,j,fval);
+ }
+
+ /* Duplicate last values in buffer to make up to 128 */
+ absraw[i][0] = absraw[i][1];
+ absraw[i][127] = absraw[i][126];
+ }
+ }
+
+ return I1PRO_OK;
+}
+
+/* Take a raw value, and convert it into an absolute raw value. */
+/* Note that linearisation is ignored, since it is assumed to be insignificant */
+/* to the black threshold and saturation values. */
+double i1pro_raw_to_absraw(
+ i1pro *p,
+ double raw, /* Input value */
+ double inttime, /* Integration time used */
+ int gainmode /* Gain mode, 0 = normal, 1 = high */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j, k;
+ double gain;
+ double scale; /* Absolute scale value */
+ double fval;
+
+ if (gainmode) {
+ gain = m->highgain;
+ } else {
+ gain = 1.0;
+ }
+ scale = 1.0/(inttime * gain);
+
+ return raw * scale;
+}
+
+
+/* Invert a polinomial equation. */
+/* Since the linearisation is nearly a straight line, */
+/* a simple Newton inversion will suffice. */
+static double inv_poly(double *polys, int npoly, double inv) {
+ double outv = inv, lval, del = 100.0;
+ int i, k;
+
+ for (i = 0; i < 200 && fabs(del) > 1e-7; i++) {
+ for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--) {
+ lval = lval * outv + polys[k];
+ }
+ del = (inv - lval);
+ outv += 0.99 * del;
+ }
+
+ return outv;
+}
+
+/* Take a single set of absolute linearised sensor values and */
+/* convert them back into Rev A..D raw reading values. */
+/* This is used for saving a calibration to the EEProm */
+i1pro_code i1pro_absraw_to_meas(
+ i1pro *p,
+ int *meas, /* Return raw measurement data */
+ double *absraw, /* Array of [-1 nraw] value to process */
+ double inttime, /* Integration time used */
+ int gainmode /* Gain mode, 0 = normal, 1 = high */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned int maxpve = m->maxpve; /* maximum +ve sensor value + 1 */
+ int i, j, k;
+ double avlastv = 0.0;
+ double gain;
+ int npoly; /* Number of linearisation coefficients */
+ double *polys; /* the coeficients */
+ double scale; /* Absolute scale value */
+
+ if (m->subtmode) {
+ a1logd(p->log,1,"i1pro_absraw_to_meas subtmode set\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ if (gainmode) {
+ gain = m->highgain;
+ npoly = m->nlin1;
+ polys = m->lin1;
+ } else {
+ gain = 1.0;
+ npoly = m->nlin0;
+ polys = m->lin0;
+ }
+ scale = 1.0/(inttime * gain);
+
+ for (j = 0; j < 128; j++) {
+ double fval, lval;
+ unsigned int rval;
+
+ /* Unscale from absolute sensor reading */
+ lval = absraw[j] / scale;
+
+#ifdef ENABLE_NONLINCOR
+ /* Un-linearise */
+ fval = inv_poly(polys, npoly, lval);
+#else
+ fval = lval;
+#endif
+
+ if (fval < (double)((int)maxpve-65536))
+ fval = (double)((int)maxpve-65536);
+ else if (fval > (double)(maxpve-1))
+ fval = (double)(maxpve-1);
+
+ rval = (unsigned int)(int)floor(fval + 0.5);
+ meas[j] = rval;
+ }
+ return I1PRO_OK;
+}
+
+/* Average a set of measurements into one. */
+/* Return zero if readings are consistent and not saturated. */
+/* Return nz with bit 1 set if the readings are not consistent */
+/* Return nz with bit 2 set if the readings are saturated */
+/* Return the highest individual element. */
+/* Return the overall average. */
+int i1pro_average_multimeas(
+ i1pro *p,
+ double *avg, /* return average [-1 nraw] */
+ double **multimeas, /* Array of [nummeas][-1 nraw] value to average */
+ int nummeas, /* number of readings to be averaged */
+ double *phighest, /* If not NULL, return highest value from all bands and msrmts. */
+ double *poallavg, /* If not NULL, return overall average of bands and measurements */
+ double satthresh, /* Sauration threshold, 0 for none */
+ double darkthresh /* Dark threshold (used for consistency check scaling) */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j;
+ double highest = -1e6;
+ double oallavg = 0.0;
+ double avgoverth = 0.0; /* Average over threshold */
+ double maxavg = -1e38; /* Track min and max averages of readings */
+ double minavg = 1e38;
+ double norm;
+ int rv = 0;
+
+ a1logd(p->log,3,"i1pro_average_multimeas %d readings\n",nummeas);
+
+ for (j = -1; j < 128; j++)
+ avg[j] = 0.0;
+
+ /* Now process the buffer values */
+ for (i = 0; i < nummeas; i++) {
+ double measavg = 0.0;
+ int k;
+
+ for (j = k = 0; j < m->nraw; j++) {
+ double val;
+
+ val = multimeas[i][j];
+
+ avg[j] += val; /* Per value average */
+
+ /* Skip 0 and 127 cell values for RevA-D */
+ if (m->nsen == m->nraw && (j == 0 || j == 127))
+ continue;
+
+ if (val > highest)
+ highest = val;
+ if (val > satthresh)
+ avgoverth++;
+ measavg += val;
+ k++;
+ }
+ measavg /= (double)k;
+ oallavg += measavg;
+ if (measavg < minavg)
+ minavg = measavg;
+ if (measavg > maxavg)
+ maxavg = measavg;
+
+ /* and shielded values */
+ avg[-1] += multimeas[i][-1];
+ }
+
+ for (j = -1; j < 128; j++)
+ avg[j] /= (double)nummeas;
+ oallavg /= (double)nummeas;
+ avgoverth /= (double)nummeas;
+
+ if (phighest != NULL)
+ *phighest = highest;
+
+ if (poallavg != NULL)
+ *poallavg = oallavg;
+
+ if (satthresh > 0.0 && avgoverth > 0.0)
+ rv |= 2;
+
+ norm = fabs(0.5 * (maxavg+minavg));
+ a1logd(p->log,4,"norm = %f, dark thresh = %f\n",norm,darkthresh);
+ if (norm < (2.0 * darkthresh))
+ norm = 2.0 * darkthresh;
+
+ a1logd(p->log,4,"overall avg = %f, minavg = %f, maxavg = %f, variance %f, shielded avg %f\n",
+ oallavg,minavg,maxavg,(maxavg - minavg)/norm, avg[-1]);
+ if ((maxavg - minavg)/norm > PATCH_CONS_THR) {
+ a1logd(p->log,2,"Reading is inconsistent: (maxavg %f - minavg %f)/norm %f = %f > thresh %f, darkthresh %f\n",maxavg,minavg,norm,(maxavg - minavg)/norm,PATCH_CONS_THR, darkthresh);
+ rv |= 1;
+ }
+ return rv;
+}
+
+/* Minimum number of scan samples in a patch */
+#define MIN_SAMPLES 3
+
+/* Range of bands to detect transitions */
+#define BL 5 /* Start */
+#define BH 105 /* End */
+#define BW 5 /* Width */
+
+/* Record of possible patch */
+typedef struct {
+ int ss; /* Start sample index */
+ int no; /* Number of samples */
+ int use; /* nz if patch is to be used */
+} i1pro_patch;
+
+/* Recognise the required number of ref/trans patch locations, */
+/* and average the measurements within each patch. */
+/* *flags returns zero if readings are consistent and not saturated. */
+/* *flags returns nz with bit 1 set if the readings are not consistent */
+/* *flags returns nz with bit 2 set if the readings are saturated */
+/* *phighest returns the highest individual element. */
+/* (Doesn't extract [-1] shielded values, since they have already been used) */
+i1pro_code i1pro_extract_patches_multimeas(
+ i1pro *p,
+ int *flags, /* return flags */
+ double **pavg, /* return patch average [naptch][-1 nraw] */
+ int tnpatch, /* Target number of patches to recognise */
+ double **multimeas, /* Array of [nummeas][-1 nraw] value to extract from */
+ int nummeas, /* number of readings made */
+ double *phighest, /* If not NULL, return highest value from all bands and msrmts. */
+ double satthresh, /* Sauration threshold, 0 for none */
+ double inttime /* Integration time (used to adjust consistency threshold) */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j, k, pix;
+ double **sslope; /* Signed difference between i and i+1 */
+ double *slope; /* Accumulated absolute difference between i and i+1 */
+ double *fslope; /* Filtered slope */
+ i1pro_patch *pat; /* Possible patch information */
+ int npat, apat = 0;
+ double *maxval; /* Maximum input value for each wavelength */
+ double fmaxslope = 0.0;
+ double maxslope = 0.0;
+ double minslope = 1e38;
+ double thresh = 0.4; /* Slope threshold */
+ int try; /* Thresholding try */
+ double avglegth; /* Average length of patches */
+ int *sizepop; /* Size popularity of potential patches */
+ double median; /* median potential patch width */
+ double window; /* +/- around median to accept */
+ double highest = -1e6;
+ double white_avg; /* Average of (aproximate) white data */
+ int b_lo = BL; /* Patch detection low band */
+ int b_hi = BH; /* Patch detection low band */
+ int rv = 0;
+ double patch_cons_thr = PATCH_CONS_THR * m->scan_toll_ratio;
+#ifdef PATREC_DEBUG
+ double **plot;
+#endif
+
+ a1logd(p->log,2,"i1pro_extract_patches_multimeas looking for %d patches out of %d samples\n",tnpatch,nummeas);
+
+ /* Adjust bands if UV mode */
+ /* (This is insufficient for useful patch recognition) */
+ if (m->uv_en) {
+ b_lo = 91;
+ b_hi = 117;
+ }
+
+ maxval = dvectorz(-1, m->nraw-1);
+
+ /* Loosen consistency threshold for short integation time, */
+ /* to allow for extra noise */
+ if (inttime < 0.012308) /* Smaller than Rev A minimum int. time */
+ patch_cons_thr *= sqrt(0.012308/inttime);
+
+ /* Discover the maximum input value for normalisation */
+ for (j = 0; j < m->nraw; j ++) {
+ for (i = 0; i < nummeas; i++) {
+ if (multimeas[i][j] > maxval[j])
+ maxval[j] = multimeas[i][j];
+ }
+ if (maxval[j] < 1.0)
+ maxval[j] = 1.0;
+ }
+
+#ifdef PATREC_DEBUG
+ /* Plot out 6 lots of 8 values each */
+ plot = dmatrixz(0, 8, 0, nummeas-1);
+// for (j = 45; j <= (m->nraw-8); j += 100) /* Do just one band */
+#ifdef PATREC_ALLBANDS
+ for (j = 0; j <= (m->nraw-8); j += 8) /* Plot all the bands */
+#else
+ for (j = 5; j <= (m->nraw-8); j += 30) /* Do four bands */
+#endif
+ {
+ for (k = 0; k < 8; k ++) {
+ for (i = 0; i < nummeas; i++) {
+ plot[k][i] = multimeas[i][j+k]/maxval[j+k];
+ }
+ }
+ for (i = 0; i < nummeas; i++)
+ plot[8][i] = (double)i;
+ printf("Bands %d - %d\n",j,j+7);
+ do_plot10(plot[8], plot[0], plot[1], plot[2], plot[3], plot[4], plot[5], plot[6], plot[7], NULL, NULL, nummeas, 0);
+ }
+#endif /* PATREC_DEBUG */
+
+ sslope = dmatrixz(0, nummeas-1, -1, m->nraw-1);
+ slope = dvectorz(0, nummeas-1);
+ fslope = dvectorz(0, nummeas-1);
+ sizepop = ivectorz(0, nummeas-1);
+
+#ifndef NEVER /* Good with this on */
+ /* Average bands together */
+ for (i = 0; i < nummeas; i++) {
+ for (j = b_lo + BW; j < (b_hi - BW); j++) {
+ for (k = -b_lo; k <= BW; k++) /* Box averaging filter over bands */
+ sslope[i][j] += multimeas[i][j + k]/maxval[j];
+ }
+ }
+#else
+ /* Don't average bands */
+ for (i = 0; i < nummeas; i++) {
+ for (j = 0; j < m->nraw; j++) {
+ sslope[i][j] = multimeas[i][j]/maxval[j];
+ }
+ }
+#endif
+
+ /* Compute slope result over readings and bands */
+ /* Compute signed slope result over readings and bands */
+
+#ifdef NEVER /* Works well for non-noisy readings */
+ /* Median of 5 differences from 6 points */
+ for (i = 2; i < (nummeas-3); i++) {
+ for (j = b_lo; j < b_hi; j++) {
+ double sl, asl[5];
+ int r, s;
+ asl[0] = fabs(sslope[i-2][j] - sslope[i-1][j]);
+ asl[1] = fabs(sslope[i-1][j] - sslope[i-0][j]);
+ asl[2] = fabs(sslope[i-0][j] - sslope[i+1][j]);
+ asl[3] = fabs(sslope[i+1][j] - sslope[i+2][j]);
+ asl[4] = fabs(sslope[i+2][j] - sslope[i+3][j]);
+
+ /* Sort them */
+ for (r = 0; r < (5-1); r++) {
+ for (s = r+1; s < 5; s++) {
+ if (asl[s] < asl[r]) {
+ double tt;
+ tt = asl[s];
+ asl[s] = asl[r];
+ asl[r] = tt;
+ }
+ }
+ }
+ /* Pick middle one */
+ sl = asl[2];
+ if (sl > slope[i])
+ slope[i] = sl;
+ }
+ }
+
+#else /* Works better for noisy readings */
+
+ /* Compute sliding window average and deviation that contains */
+ /* our output point, and chose the average with the minimum deviation. */
+#define FW 3 /* Number of delta's to average */
+ for (i = FW-1; i < (nummeas-FW); i++) { /* Samples */
+ double basl, bdev; /* Best average slope, Best deviation */
+ double sl[2 * FW -1];
+ double asl[FW], dev[FW];
+ int slopen = 0;
+ double slopeth = 0.0;
+ int m, pp;
+
+ for (pp = 0; pp < 2; pp++) { /* For each pass */
+
+ for (j = b_lo; j < b_hi; j++) { /* Bands */
+
+ /* Compute differences for the range of our windows */
+ for (k = 0; k < (2 * FW -1); k++)
+ sl[k] = sslope[i+k-FW+1][j] - sslope[i+k+-FW+2][j];
+
+ /* For each window offset, compute average and deviation squared */
+ bdev = 1e38;
+ for (k = 0; k < FW; k++) {
+
+ /* Compute average of this window offset */
+ asl[k] = 0.0;
+ for (m = 0; m < FW; m++) /* For slope in window */
+ asl[k] += sl[k+m];
+ asl[k] /= (double)FW;
+
+ /* Compute deviation squared */
+ dev[k] = 0.0;
+ for (m = 0; m < FW; m++) {
+ double tt;
+ tt = sl[k+m] - asl[k];
+ dev[k] += tt * tt;
+ }
+ if (dev[k] < bdev)
+ bdev = dev[k];
+ }
+
+#ifndef NEVER
+ /* Weight the deviations with a triangular weighting */
+ /* to skew slightly towards the center */
+ for (k = 0; k < FW; k++) {
+ double wt;
+
+ wt = fabs(2.0 * k - (FW -1.0))/(FW-1.0);
+ dev[k] += wt * bdev;
+ }
+#endif
+
+ /* For each window offset, choose the one to use. */
+ bdev = 1e38;
+ basl = 0.0;
+ for (k = 0; k < FW; k++) {
+
+ /* Choose window average with smallest deviation squared */
+ if (dev[k] < bdev) {
+ bdev = dev[k];
+ basl = fabs(asl[k]);
+ }
+ }
+
+ if (pp == 0) { /* First pass, compute average slope over bands */
+ slope[i] += basl;
+
+ } else { /* Second pass, average slopes of bands over threshold */
+ if (basl > slopeth) {
+ slope[i] += basl;
+ slopen++;
+ }
+ }
+ } /* Next band */
+
+ if (pp == 0) {
+ slopeth = 1.0 * slope[i]/j; /* Compute threshold */
+ slope[i] = 0.0;
+ } else {
+ if (slopen > 0)
+ slope[i] /= slopen; /* Compute average of those over threshold */
+ }
+ } /* Next pass */
+ }
+#undef FW
+#endif
+
+#ifndef NEVER /* Good with this on */
+ /* Normalise the slope values */
+ /* Locate the minumum and maximum values */
+ maxslope = 0.0;
+ minslope = 1e38;
+ for (i = 4; i < (nummeas-4); i++) {
+ double avs;
+
+ if (slope[i] > maxslope)
+ maxslope = slope[i];
+
+ /* Simple moving average for min comp. */
+ avs = 0.0;
+ for (j = -2; j <= 2; j++)
+ avs += slope[i+j];
+ avs /= 5.0;
+ if (avs < minslope)
+ minslope = avs;
+ }
+
+ /* Normalise the slope */
+ maxslope *= 0.5;
+ minslope *= 3.0;
+ for (i = 0; i < nummeas; i++) {
+ slope[i] = (slope[i] - minslope) / (maxslope - minslope);
+ if (slope[i] < 0.0)
+ slope[i] = 0.0;
+ else if (slope[i] > 1.0)
+ slope[i] = 1.0;
+ }
+
+ /* "Automatic Gain control" the raw slope information. */
+#define LFW 20 /* Half width of triangular filter */
+ for (i = 0; i < nummeas; i++) {
+ double sum, twt;
+
+ sum = twt = 0.0;
+ for (j = -LFW; j <= LFW; j++) {
+ double wt;
+ if ((i+j) < 0 || (i+j) >= nummeas)
+ continue;
+
+ wt = ((LFW-abs(j))/(double)LFW);
+
+ sum += wt * slope[i+j];
+ twt += wt;
+ }
+ fslope[i] = sum/twt;
+ if (fslope[i] > fmaxslope)
+ fmaxslope = fslope[i];
+ }
+#undef LFW
+
+#ifdef NEVER /* Better with the off, for very noisy samples */
+ /* Apply AGC with limited gain */
+ for (i = 0; i < nummeas; i++) {
+ if (fslope[i] > fmaxslope/4.0)
+ slope[i] = slope[i]/fslope[i];
+ else
+ slope[i] = slope[i] * 4.0/fmaxslope;
+ }
+#endif
+#endif /* NEVER */
+
+ /* Locate the minumum and maximum values */
+ maxslope = 0.0;
+ minslope = 1e38;
+ for (i = 4; i < (nummeas-4); i++) {
+ double avs;
+
+ if (slope[i] > maxslope)
+ maxslope = slope[i];
+
+ /* Simple moving average for min comp. */
+ avs = 0.0;
+ for (j = -2; j <= 2; j++)
+ avs += slope[i+j];
+ avs /= 5.0;
+ if (avs < minslope)
+ minslope = avs;
+ }
+
+#ifndef NEVER /* Good with this on */
+ /* Normalise the slope again */
+ maxslope *= 0.3;
+ minslope *= 3.0;
+ for (i = 0; i < nummeas; i++) {
+ slope[i] = (slope[i] - minslope) / (maxslope - minslope);
+ if (slope[i] < 0.0)
+ slope[i] = 0.0;
+ else if (slope[i] > 1.0)
+ slope[i] = 1.0;
+ }
+#endif
+
+#ifdef PATREC_DEBUG
+ printf("Slope filter output\n");
+ for (i = 0; i < nummeas; i++) {
+ int jj;
+ for (jj = 0, j = b_lo; jj < 6 && j < b_hi; jj++, j += ((b_hi-b_lo)/6)) {
+ double sum = 0.0;
+ for (k = -b_lo; k <= BW; k++) /* Box averaging filter over bands */
+ sum += multimeas[i][j + k];
+ plot[jj][i] = sum/((2.0 * b_lo + 1.0) * maxval[j+k]);
+ }
+ }
+ for (i = 0; i < nummeas; i++)
+ plot[6][i] = (double)i;
+ do_plot6(plot[6], slope, plot[0], plot[1], plot[2], plot[3], plot[4], nummeas);
+#endif /* PATREC_DEBUG */
+
+ free_dvector(fslope, 0, nummeas-1);
+ free_dmatrix(sslope, 0, nummeas-1, -1, m->nraw-1);
+
+ /* Now threshold the measurements into possible patches */
+ apat = 2 * nummeas;
+ if ((pat = (i1pro_patch *)malloc(sizeof(i1pro_patch) * apat)) == NULL) {
+ a1logd(p->log, 1, "i1pro: malloc of patch structures failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ avglegth = 0.0;
+ for (npat = i = 0; i < (nummeas-1); i++) {
+ if (slope[i] > thresh)
+ continue;
+
+ /* Start of a new patch */
+ if (npat >= apat) {
+ apat *= 2;
+ if ((pat = (i1pro_patch *)realloc(pat, sizeof(i1pro_patch) * apat)) == NULL) {
+ a1logd(p->log, 1, "i1pro: reallloc of patch structures failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+ }
+ pat[npat].ss = i;
+ pat[npat].no = 2;
+ pat[npat].use = 0;
+ for (i++; i < (nummeas-1); i++) {
+ if (slope[i] > thresh)
+ break;
+ pat[npat].no++;
+ }
+ avglegth += (double) pat[npat].no;
+ npat++;
+ }
+ a1logd(p->log,7,"Number of patches = %d\n",npat);
+
+ /* We don't count the first and last patches, as we assume they are white leader */
+ if (npat < (tnpatch + 2)) {
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(slope, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+ a1logd(p->log,2,"Patch recog failed - unable to detect enough possible patches\n");
+ return I1PRO_RD_NOTENOUGHPATCHES;
+ } else if (npat >= (2 * tnpatch) + 2) {
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(slope, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+ a1logd(p->log,2,"Patch recog failed - detecting too many possible patches\n");
+ return I1PRO_RD_TOOMANYPATCHES;
+ }
+ avglegth /= (double)npat;
+
+ for (i = 0; i < npat; i++) {
+ a1logd(p->log,7,"Raw patch %d, start %d, length %d\n",i, pat[i].ss, pat[i].no);
+ }
+
+ /* Accumulate popularity ccount of possible patches */
+ for (i = 1; i < (npat-1); i++)
+ sizepop[pat[i].no]++;
+
+ /* Locate the median potential patch width */
+ for (j = 0, i = 0; i < nummeas; i++) {
+ j += sizepop[i];
+ if (j >= ((npat-2)/2))
+ break;
+ }
+ median = (double)i;
+
+ a1logd(p->log,7,"Median patch width %f\n",median);
+
+ /* Now decide which patches to use. */
+ /* Try a widening window around the median. */
+ for (window = 0.2, try = 0; try < 15; window *= 1.4, try++) {
+ int bgcount = 0, bgstart = 0;
+ int gcount, gstart;
+ double wmin = median/(1.0 + window);
+ double wmax = median * (1.0 + window);
+
+ a1logd(p->log,7,"Window = %f - %f\n",wmin, wmax);
+ /* Track which is the largest contiguous group that */
+ /* is within our window */
+ gcount = gstart = 0;
+ for (i = 1; i < npat; i++) {
+ if (i < (npat-1) && pat[i].no <= wmax) { /* Small enough */
+ if (pat[i].no >= wmin) { /* And big enough */
+ if (gcount == 0) { /* Start of new group */
+ gcount++;
+ gstart = i;
+ a1logd(p->log,7,"Start group at %d\n",gstart);
+ } else {
+ gcount++; /* Continuing new group */
+ a1logd(p->log,7,"Continue group at %d, count %d\n",gstart,gcount);
+ }
+ }
+ } else { /* Too big or end of patches, end this group */
+ a1logd(p->log,7,"Terminating group group at %d, count %d\n",gstart,gcount);
+ if (gcount > bgcount) { /* New biggest group */
+ bgcount = gcount;
+ bgstart = gstart;
+ a1logd(p->log,7,"New biggest\n");
+ }
+ gcount = gstart = 0; /* End this group */
+ }
+ }
+ a1logd(p->log,7,"Biggest group is at %d, count %d\n",bgstart,bgcount);
+
+ if (bgcount == tnpatch) { /* We're done */
+ for (i = bgstart, j = 0; i < npat && j < tnpatch; i++) {
+ if (pat[i].no <= wmax && pat[i].no >= wmin) {
+ pat[i].use = 1;
+ j++;
+ if (pat[i].no < MIN_SAMPLES) {
+ a1logd(p->log,7,"Too few samples\n");
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(slope, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+ a1logd(p->log,2,"Patch recog failed - patches sampled too sparsely\n");
+ return I1PRO_RD_NOTENOUGHSAMPLES;
+ }
+ }
+ }
+ break;
+
+ } else if (bgcount > tnpatch) {
+ a1logd(p->log,7,"Too many patches\n");
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(slope, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+ a1logd(p->log,2,"Patch recog failed - detected too many consistent patches\n");
+ return I1PRO_RD_TOOMANYPATCHES;
+ }
+ }
+ if (try >= 15) {
+ a1logd(p->log,7,"Not enough patches\n");
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(slope, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+ a1logd(p->log,2,"Patch recog failed - unable to find enough consistent patches\n");
+ return I1PRO_RD_NOTENOUGHPATCHES;
+ }
+
+ a1logd(p->log,7,"Got %d patches out of potential %d:\n",tnpatch, npat);
+ a1logd(p->log,7,"Average patch legth %f\n",avglegth);
+ for (i = 1; i < (npat-1); i++) {
+ if (pat[i].use == 0)
+ continue;
+ a1logd(p->log,7,"Patch %d, start %d, length %d:\n",i, pat[i].ss, pat[i].no, pat[i].use);
+ }
+
+ /* Now trim the patches simply by shrinking their windows */
+ for (k = 1; k < (npat-1); k++) {
+ int nno, trim;
+
+ if (pat[k].use == 0)
+ continue;
+
+
+ nno = (pat[k].no * 3)/4;
+ trim = (pat[k].no - nno)/2;
+
+ pat[k].ss += trim;
+ pat[k].no = nno;
+ }
+
+#ifdef PATREC_DEBUG
+ a1logd(p->log,7,"After trimming got:\n");
+ for (i = 1; i < (npat-1); i++) {
+ if (pat[i].use == 0)
+ continue;
+ printf("Patch %d, start %d, length %d:\n",i, pat[i].ss, pat[i].no, pat[i].use);
+ }
+
+ /* Create fake "slope" value that marks patches */
+ for (i = 0; i < nummeas; i++)
+ slope[i] = 1.0;
+ for (k = 1; k < (npat-1); k++) {
+ if (pat[k].use == 0)
+ continue;
+ for (i = pat[k].ss; i < (pat[k].ss + pat[k].no); i++)
+ slope[i] = 0.0;
+ }
+
+ printf("Trimmed output:\n");
+ for (i = 0; i < nummeas; i++) {
+ int jj;
+ for (jj = 0, j = b_lo; jj < 6 && j < b_hi; jj++, j += ((b_hi-b_lo)/6)) {
+ double sum = 0.0;
+ for (k = -b_lo; k <= BW; k++) /* Box averaging filter over bands */
+ sum += multimeas[i][j + k];
+ plot[jj][i] = sum/((2.0 * b_lo + 1.0) * maxval[j+k]);
+ }
+ }
+ for (i = 0; i < nummeas; i++)
+ plot[6][i] = (double)i;
+ do_plot6(plot[6], slope, plot[0], plot[1], plot[2], plot[3], plot[4], nummeas);
+#endif /* PATREC_DEBUG */
+
+#ifdef PATREC_DEBUG
+ free_dmatrix(plot, 0, 6, 0, nummeas-1);
+#endif /* PATREC_DEBUG */
+
+ /* Compute average of (aproximate) white */
+ white_avg = 0.0;
+ for (j = 1; j < (m->nraw-1); j++)
+ white_avg += maxval[j];
+ white_avg /= (m->nraw - 2.0);
+
+ /* Now process the buffer values */
+ for (i = 0; i < tnpatch; i++) {
+ for (j = 0; j < m->nraw; j++)
+ pavg[i][j] = 0.0;
+ }
+
+ for (pix = 0, k = 1; k < (npat-1); k++) {
+ double maxavg = -1e38; /* Track min and max averages of readings for consistency */
+ double minavg = 1e38;
+ double avgoverth = 0.0; /* Average over saturation threshold */
+ double cons; /* Consistency */
+
+ if (pat[k].use == 0)
+ continue;
+
+ if (pat[k].no <= MIN_SAMPLES) {
+ a1logd(p->log,7,"Too few samples (%d, need %d)\n",pat[k].no,MIN_SAMPLES);
+ free_dvector(slope, 0, nummeas-1);
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+ a1logd(p->log,2,"Patch recog failed - patches sampled too sparsely\n");
+ return I1PRO_RD_NOTENOUGHSAMPLES;
+ }
+
+ /* Measure samples that make up patch value */
+ for (i = pat[k].ss; i < (pat[k].ss + pat[k].no); i++) {
+ double measavg = 0.0;
+
+ for (j = 1; j < m->nraw-1; j++) {
+ double val;
+
+ val = multimeas[i][j];
+
+ if (val > highest)
+ highest = val;
+ if (val > satthresh)
+ avgoverth++;
+ measavg += val;
+ pavg[pix][j] += val;
+ }
+ measavg /= (m->nraw-2.0);
+ if (measavg < minavg)
+ minavg = measavg;
+ if (measavg > maxavg)
+ maxavg = measavg;
+
+ /* and the duplicated values at the end */
+ pavg[pix][0] += multimeas[i][0];
+ pavg[pix][127] += multimeas[i][127];
+ }
+
+ for (j = 0; j < m->nraw; j++)
+ pavg[pix][j] /= (double)pat[k].no;
+ avgoverth /= (double)pat[k].no;
+
+ if (satthresh > 0.0 && avgoverth >= 10.0)
+ rv |= 2;
+
+ cons = (maxavg - minavg)/white_avg;
+ a1logd(p->log,7,"Patch %d: consistency = %f%%, thresh = %f%%\n",pix,100.0 * cons, 100.0 * patch_cons_thr);
+ if (cons > patch_cons_thr) {
+ a1logd(p->log,2,"Patch recog failed - patch %d is inconsistent (%f%% > %f)\n",pix,cons, patch_cons_thr);
+ rv |= 1;
+ }
+ pix++;
+ }
+
+ if (phighest != NULL)
+ *phighest = highest;
+ if (flags != NULL)
+ *flags = rv;
+
+ free_dvector(slope, 0, nummeas-1);
+ free_ivector(sizepop, 0, nummeas-1);
+ free_dvector(maxval, -1, m->nraw-1);
+ free(pat);
+
+ if (rv & 2)
+ a1logd(p->log,2,"Patch recog failed - some patches are saturated\n");
+
+ a1logd(p->log,2,"i1pro_extract_patches_multimeas done, sat = %s, inconsist = %s\n",
+ rv & 2 ? "true" : "false", rv & 1 ? "true" : "false");
+
+ return I1PRO_OK;
+}
+#undef BL
+#undef BH
+#undef BW
+
+
+/* Recognise any flashes in the readings, and */
+/* and average their values together as well as summing their duration. */
+/* Return nz on an error */
+/* (Doesn't extract [-1] shielded values, since they have already been used) */
+i1pro_code i1pro_extract_patches_flash(
+ i1pro *p,
+ int *flags, /* return flags */
+ double *duration, /* return duration */
+ double *pavg, /* return patch average [-1 nraw] */
+ double **multimeas, /* Array of [nummeas][-1 nraw] value to extract from */
+ int nummeas, /* number of readings made */
+ double inttime /* Integration time (used to compute duration) */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j, k, pix;
+ double minval, maxval; /* min and max input value at wavelength of maximum input */
+ double mean; /* Mean of the max wavelength band */
+ int maxband; /* Band of maximum value */
+ double thresh; /* Level threshold */
+ int fsampl; /* Index of the first sample over the threshold */
+ int nsampl; /* Number of samples over the threshold */
+ double *aavg; /* ambient average [-1 nraw] */
+ double finttime; /* Flash integration time */
+ int rv = 0;
+#ifdef PATREC_DEBUG
+ double **plot;
+#endif
+
+ a1logd(p->log,2,"i1pro_extract_patches_flash looking for flashes in %d measurements\n",nummeas);
+
+ /* Discover the maximum input value for flash dection */
+ maxval = -1e6;
+ maxband = 0;
+ for (j = 0; j < m->nraw; j ++) {
+ for (i = 0; i < nummeas; i++) {
+ if (multimeas[i][j] > maxval) {
+ maxval = multimeas[i][j];
+ maxband = j;
+ }
+ }
+ }
+
+ if (maxval <= 0.0) {
+ a1logd(p->log,2,"No flashes found in measurement\n");
+ return I1PRO_RD_NOFLASHES;
+ }
+
+ minval = 1e6;
+ mean = 0.0;
+ for (i = 0; i < nummeas; i++) {
+ mean += multimeas[i][maxband];
+ if (multimeas[i][maxband] < minval)
+ minval = multimeas[i][maxband];
+ }
+ mean /= (double)nummeas;
+
+ /* Set the threshold at 5% from mean towards max */
+ thresh = (3.0 * mean + maxval)/4.0;
+ a1logd(p->log,7,"i1pro_extract_patches_flash band %d minval %f maxval %f, mean = %f, thresh = %f\n",maxband,minval,maxval,mean, thresh);
+
+#ifdef PATREC_DEBUG
+ /* Plot out 6 lots of 6 values each */
+ plot = dmatrixz(0, 6, 0, nummeas-1);
+ for (j = maxband -3; j>= 0 && j < (m->nraw-6); j += 100) /* Do one set around max */
+ {
+ for (k = 0; k < 6; k ++) {
+ for (i = 0; i < nummeas; i++) {
+ plot[k][i] = multimeas[i][j+k]/maxval;
+ }
+ }
+ for (i = 0; i < nummeas; i++)
+ plot[6][i] = (double)i;
+ printf("Bands %d - %d\n",j,j+5);
+ do_plot6(plot[6], plot[0], plot[1], plot[2], plot[3], plot[4], plot[5], nummeas);
+ }
+ free_dmatrix(plot,0,6,0,nummeas-1);
+#endif /* PATREC_DEBUG */
+
+#ifdef PATREC_DEBUG
+ /* Plot just the pulses */
+ {
+ int start, end;
+
+ plot = dmatrixz(0, 6, 0, nummeas-1);
+
+ for(j = 0, start = -1, end = 0;;) {
+
+ for (start = -1, i = end; i < nummeas; i++) {
+ if (multimeas[i][maxband] >= thresh) {
+ if (start < 0)
+ start = i;
+ } else if (start >= 0) {
+ end = i;
+ break;
+ }
+ }
+ if (start < 0)
+ break;
+ start -= 3;
+ if (start < 0)
+ start = 0;
+ end += 4;
+ if (end > nummeas)
+ end = nummeas;
+
+ for (i = start; i < end; i++, j++) {
+ int q;
+
+ plot[6][j] = (double)j;
+#ifdef NEVER /* Plot +/-3 around maxband */
+ for (q = 0, k = maxband -3; k < (maxband+3) && k >= 0 && k < m->nraw; k++, q++) {
+ plot[q][j] = multimeas[i][k]/maxval;
+ }
+#else
+ /* plot max of bands in 6 segments */
+ for (q = 0; q < 6; q++) {
+ int ss, ee;
+
+ plot[q][j] = -1e60;
+ ss = q * (m->nraw/6);
+ ee = (q+1) * (m->nraw/6);
+ for (k = ss; k < ee; k++) {
+ if (multimeas[i][k]/maxval > plot[q][j])
+ plot[q][j] = multimeas[i][k]/maxval;
+ }
+ }
+#endif
+ }
+ }
+ do_plot6(plot[6], plot[0], plot[1], plot[2], plot[3], plot[4], plot[5], j);
+ free_dmatrix(plot,0,6,0,nummeas-1);
+ }
+#endif
+
+ /* Locate the first sample over the threshold, and the */
+ /* total number of samples in the pulses. */
+ fsampl = -1;
+ for (nsampl = i = 0; i < nummeas; i++) {
+ for (j = 0; j < m->nraw-1; j++) {
+ if (multimeas[i][j] >= thresh)
+ break;
+ }
+ if (j < m->nraw-1) {
+ if (fsampl < 0)
+ fsampl = i;
+ nsampl++;
+ }
+ }
+ a1logd(p->log,7,"Number of flash patches = %d\n",nsampl);
+ if (nsampl == 0)
+ return I1PRO_RD_NOFLASHES;
+
+ /* See if there are as many samples before the first flash */
+ if (nsampl < 6)
+ nsampl = 6;
+
+ /* Average nsample samples of ambient */
+ i = (fsampl-3-nsampl);
+ if (i < 0)
+ return I1PRO_RD_NOAMBB4FLASHES;
+ a1logd(p->log,7,"Ambient samples %d to %d \n",i,fsampl-3);
+ aavg = dvectorz(-1, m->nraw-1);
+ for (nsampl = 0; i < (fsampl-3); i++) {
+ for (j = 0; j < m->nraw-1; j++)
+ aavg[j] += multimeas[i][j];
+ nsampl++;
+ }
+
+ /* Average all the values over the threshold, */
+ /* and also one either side of flash */
+ for (j = 0; j < m->nraw-1; j++)
+ pavg[j] = 0.0;
+
+ for (k = 0, i = 1; i < (nummeas-1); i++) {
+ int sample = 0;
+ for (j = 0; j < m->nraw-1; j++) {
+ if (multimeas[i-1][j] >= thresh) {
+ sample = 1;
+ break;
+ }
+ if (multimeas[i][j] >= thresh) {
+ sample = 1;
+ break;
+ }
+ if (multimeas[i+1][j] >= thresh) {
+ sample = 1;
+ break;
+ }
+ }
+ if (j < m->nraw-1) {
+ a1logd(p->log,7,"Integrating flash sample no %d \n",i);
+ for (j = 0; j < m->nraw-1; j++)
+ pavg[j] += multimeas[i][j];
+ k++;
+ }
+ }
+ for (j = 0; j < m->nraw-1; j++)
+ pavg[j] = pavg[j]/(double)k - aavg[j]/(double)nsampl;
+
+ a1logd(p->log,7,"Number of flash patches integrated = %d\n",k);
+
+ finttime = inttime * (double)k;
+ if (duration != NULL)
+ *duration = finttime;
+
+ /* Convert to cd/m^2 seconds */
+ for (j = 0; j < m->nraw-1; j++)
+ pavg[j] *= finttime;
+
+ if (flags != NULL)
+ *flags = rv;
+
+ free_dvector(aavg, -1, m->nraw-1);
+
+ return I1PRO_OK;
+}
+
+
+/* Subtract the black level. */
+/* If Rev E, also adjust according to shielded cells, and linearise. */
+void i1pro_sub_absraw(
+ i1pro *p,
+ int nummeas, /* Return number of readings measured */
+ double inttime, /* Integration time used */
+ int gainmode, /* Gain mode, 0 = normal, 1 = high */
+ double **absraw, /* Source/Desination array [-1 nraw] */
+ double *sub /* Black value to subtract [-1 nraw] */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ double gain;
+ int npoly; /* Number of linearisation coefficients */
+ double *polys; /* the coeficients */
+ double scale; /* Absolute scale value */
+ double submax = -1e6; /* Subtraction value maximum */
+ int i, j;
+
+ if (gainmode) {
+ gain = m->highgain;
+ npoly = m->nlin1;
+ polys = m->lin1;
+ } else {
+ gain = 1.0;
+ npoly = m->nlin0;
+ polys = m->lin0;
+ }
+ scale = 1.0/(inttime * gain); /* To scale RevE linearity */
+
+ /* Adjust black to allow for temperature change by using the */
+ /* shielded cell values as a reference. */
+ /* We use a heuristic to compute a zero based scale for adjusting the */
+ /* black. It's not clear why it works best this way, or how */
+ /* dependent on the particular instrument the magic numbers are, */
+ /* but it reduces the black level error from over 10% to about 0.3% */
+ if (p->itype == instI1Pro2) {
+// double xx[NSEN_MAX], in[NSEN_MAX], res[NSEN_MAX];
+ double asub[NSEN_MAX];
+ double avgscell, zero;
+
+ /* Locate largest of black */
+ for (j = 0; j < m->nraw; j++) {
+ if (sub[j] > submax)
+ submax = sub[j];
+ }
+
+ /* Average the shielded cell value of all the readings */
+ avgscell = 0.0;
+ for (i = 0; i < nummeas; i++)
+ avgscell += absraw[i][-1];
+ avgscell /= (double)nummeas;
+
+ /* Compute scaling zero */
+ zero = 1.144 * 0.5 * (avgscell + sub[-1]);
+
+ /* make sure that the zero point is above any black value */
+ if (zero < (1.01 * avgscell))
+ zero = 1.01 * avgscell;
+ if (zero < (1.01 * sub[-1]))
+ zero = 1.01 * sub[-1];
+ if (zero < (1.01 * submax))
+ zero = 1.01 * submax;
+
+ a1logd(p->log,2,"Black shielded value = %f, Reading shielded value = %f\n",sub[-1], avgscell);
+ /* Compute the adjusted black */
+ for (j = 0; j < m->nraw; j++) {
+#ifdef NEVER
+ /* simple additive correction */
+# pragma message("######### i1pro2 Simple shielded cell temperature correction! ########")
+ asub[j] = sub[j] + avgscell - sub[-1];
+#else
+ /* heuristic scaled correction */
+ asub[j] = zero - (zero - sub[j]) * (zero - avgscell)/(zero - sub[-1]);
+#endif
+ }
+
+ /* Subtract the black */
+ for (i = 0; i < nummeas; i++) {
+ for (j = 0; j < m->nraw; j++) {
+// xx[j] = j, in[j] = absraw[i][j];
+
+ absraw[i][j] -= asub[j]; /* Subtract adjusted black */
+
+// res[j] = absraw[i][j] + (double)((int)(avgscell/20.0)) * 20.0;
+#ifdef ENABLE_NONLINCOR
+ /* Linearise */
+ {
+ int k;
+ double fval, lval;
+
+ fval = absraw[i][j] / scale; /* Scale back to sensor value range */
+
+ for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--)
+ lval = lval * fval + polys[k];
+
+ absraw[i][j] = scale * lval; /* Rescale back to absolute range */
+ }
+#endif
+ }
+#ifdef PLOT_BLACK_SUBTRACT /* Plot black adjusted levels */
+ printf("black = meas, red = black, green = adjuste black, blue = result\n");
+ do_plot6(xx, in, sub, adjsub, res, NULL, NULL, m->nraw);
+#endif
+ }
+
+ /* Rev A-D don't have shielded reference cells */
+ } else {
+
+ /* For each measurement */
+ for (i = 0; i < nummeas; i++) {
+ for (j = -1; j < m->nraw; j++) {
+ absraw[i][j] -= sub[j];
+ }
+ }
+ }
+}
+
+/* Convert an absraw array from raw wavelengths to output wavelenths */
+/* for a given [std res, high res] and [emis/tras, reflective] mode */
+void i1pro_absraw_to_abswav(
+ i1pro *p,
+ int highres, /* 0 for std res, 1 for high res */
+ int refl, /* 0 for emis/trans, 1 for reflective */
+ int nummeas, /* Return number of readings measured */
+ double **abswav, /* Desination array [nwav] */
+ double **absraw /* Source array [-1 nraw] */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j, k, cx, sx;
+ double *tm; /* Temporary array */
+
+ tm = dvector(0, m->nwav[highres]-1);
+
+ /* For each measurement */
+ for (i = 0; i < nummeas; i++) {
+
+ /* For each output wavelength */
+ for (cx = j = 0; j < m->nwav[highres]; j++) {
+ double oval = 0.0;
+
+ /* For each matrix value */
+ sx = m->mtx[highres][refl].index[j]; /* Starting index */
+ for (k = 0; k < m->mtx[highres][refl].nocoef[j]; k++, cx++, sx++) {
+ oval += m->mtx[highres][refl].coef[cx] * absraw[i][sx];
+ }
+ abswav[i][j] = tm[j] = oval;
+ }
+
+ if (p->itype == instI1Pro2) {
+ /* Now apply stray light compensation */
+ /* For each output wavelength */
+ for (j = 0; j < m->nwav[highres]; j++) {
+ double oval = 0.0;
+
+ /* For each matrix value */
+ for (k = 0; k < m->nwav[highres]; k++)
+ oval += m->straylight[highres][j][k] * tm[k];
+ abswav[i][j] = oval;
+ }
+#ifdef PLOT_DEBUG
+ printf("Before & after stray light correction:\n");
+ plot_wav_2(m, highres, tm, abswav[i]);
+#endif /* PLOT_DEBUG */
+ }
+ }
+ free_dvector(tm, 0, m->nwav[highres]-1);
+}
+
+/* Convert an abswav array of output wavelengths to scaled output readings. */
+void i1pro_scale_specrd(
+ i1pro *p,
+ double **outspecrd, /* Destination */
+ int numpatches, /* Number of readings/patches */
+ double **inspecrd /* Source */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ int i, j;
+
+ /* For each measurement */
+ for (i = 0; i < numpatches; i++) {
+
+ /* For each output wavelength */
+ for (j = 0; j < m->nwav[m->highres]; j++) {
+ outspecrd[i][j] = inspecrd[i][j] * s->cal_factor[m->highres][j];
+ }
+ }
+}
+
+
+/* =============================================== */
+/* Rev E wavelength calibration */
+
+/*
+ The Rev E has a wavelength reference LED amd
+ stores a reference raw spectrum of it in its
+ calibrated state, together with an polinomial
+ defining the raw bin no. to wavelength conversion.
+
+ By measuring the wavelength LED and finding
+ the best positional match against the reference
+ spectrum, a CCD bin offset can be computed
+ to compensate for any shift in the optical or
+ physical alignment of spectrum against CCD.
+
+ To use the adjustment, the raw to wave subsampling
+ filters need to be regenerated, and to ensure that
+ the instrument returns readings very close to the
+ manufacturers driver, the same underlying filter
+ creation mathematics needs to be used.
+
+ The manufacturers filter weights are the accumulated
+ third order Lagrange polynomial weights of the
+ integration of a 20 nm wide triange spectrum
+ centered at each output wavelength, discretely
+ integrated between the range of the middle two points
+ of the Lagrange interpolator. The triangle response
+ being integrated has an area of exactly 1.0.
+
+ */
+
+/* Invert a raw2wavlength polinomial equation. */
+/* Use simple Newton inversion will suffice. */
+static double inv_raw2wav(double *polys, int npoly, double inv) {
+ double outv = 560.0, lval, del = 100.0;
+ int i, k;
+
+ for (i = 0; i < 200 && fabs(del) > 1e-7; i++) {
+ for (lval = polys[npoly-1], k = npoly-2; k >= 0; k--) {
+ lval = lval * outv + polys[k];
+ }
+ del = (inv - lval);
+ outv += 0.4 * del;
+ }
+
+ return 128.0 - outv;
+}
+
+/* return the uncalibrated wavelength given a raw bin value */
+/* (Always uses reflective RevE wav2cal) */
+static double i1pro_raw2wav_uncal(i1pro *p, double raw) {
+ i1proimp *m = (i1proimp *)p->m;
+ double ov;
+ int k;
+
+ if (p->itype == instI1Pro2) {
+ raw = 128.0 - raw; /* Quadratic expects +ve correlation */
+
+ /* Compute polinomial */
+ for (ov = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+ ov = ov * raw + m->wlpoly1[k];
+ } else {
+ co pp;
+
+ if (m->raw2wav == NULL) {
+ a1loge(p->log,1,"i1pro_raw2wav_uncal called when hi-res not inited\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ pp.p[0] = raw;
+ m->raw2wav->interp(m->raw2wav, &pp);
+ ov = pp.v[0];
+ }
+
+ return ov;
+}
+
+/* return the calibrated wavelength given a raw bin value for the given mode */
+static double i1pro_raw2wav(i1pro *p, int refl, double raw) {
+ i1proimp *m = (i1proimp *)p->m;
+ double ov;
+ int k;
+
+ if (p->itype == instI1Pro2) {
+ i1pro_state *s = &m->ms[m->mmode];
+
+ /* Correct for CCD offset and scale back to reference */
+ raw = raw - s->wl_led_off + m->wl_led_ref_off;
+
+ raw = 128.0 - raw; /* Quadratic expects +ve correlation */
+
+ /* Compute polinomial */
+ if (refl) {
+ for (ov = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+ ov = ov * raw + m->wlpoly1[k];
+ } else {
+ for (ov = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+ ov = ov * raw + m->wlpoly2[k];
+ }
+ } else {
+ co pp;
+
+ /* If not RevE there is no WL calibration */
+ if (m->raw2wav == NULL) {
+ a1loge(p->log,1,"i1pro_raw2wav_uncal called when hi-res not inited\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ pp.p[0] = raw;
+ m->raw2wav->interp(m->raw2wav, &pp);
+ ov = pp.v[0];
+ }
+
+ return ov;
+}
+
+/* Powell minimisation contxt for WL calibration */
+typedef struct {
+ double ref_max; /* reference maximum level */
+ double *wl_ref; /* Wavlength reference samples */
+ int wl_ref_n; /* Number of wavelength references */
+ double *wl_meas; /* Wavelength measurement samples */
+ int wl_meas_n; /* Number of wavelength measurement samples */
+ int plot; /* Plot each try */
+} wlcal_cx;
+
+/* Powell minimisation callback function */
+/* Parameters being optimized are magnitude, offset and scale */
+static double wlcal_opt1(void *vcx, double tp[]) {
+#ifdef PLOT_DEBUG
+ int pix = 0;
+ double xx[1024];
+ double y1[1024]; /* interpolate ref */
+ double y2[1024]; /* Measurement */
+ double y3[1024]; /* Error */
+#endif
+ wlcal_cx *cx = (wlcal_cx *)vcx;
+ double vv, rv = 0.0;
+ int si, i;
+
+ si = (int)tp[1];
+
+ /* i = Measurement index */
+ for (i = si; i < cx->wl_meas_n; i++) {
+
+ double xv; /* offset & scaled measurement index */
+ int ix; /* Lagrange base offset */
+ double yv;
+
+ xv = ((double)i - tp[1]); /* fitted measurement location in reference no scale */
+
+ ix = ((int)xv) - 1; /* Reference index of Lagrange for this xv */
+ if (ix < 0)
+ continue;
+ if ((ix + 3) > cx->wl_ref_n)
+ break;
+
+ /* Compute interpolated value of reference using Lagrange: */
+ yv = cx->wl_ref[ix+0] * (xv-(ix+1)) * (xv-(ix+2)) * (xv-(ix+3))
+ /((0.0-1.0) * (0.0-2.0) * (0.0-3.0))
+ + cx->wl_ref[ix+1] * (xv-(ix+0)) * (xv-(ix+2)) * (xv-(ix+3))
+ /((1.0-0.0) * (1.0-2.0) * (1.0-3.0))
+ + cx->wl_ref[ix+2] * (xv-(ix+0)) * (xv-(ix+1)) * (xv-(ix+3))
+ /((2.0-0.0) * (2.0-1.0) * (2.0-3.0))
+ + cx->wl_ref[ix+3] * (xv-(ix+0)) * (xv-(ix+1)) * (xv-(ix+2))
+ /((3.0-0.0) * (3.0-1.0) * (3.0-2.0));
+ vv = yv - tp[0] * cx->wl_meas[i];
+
+ /* Weight error linearly with magnitude, to emphasise peak error */
+ /* rather than what's happening down in the noise */
+ vv = vv * vv * (yv + 1.0)/(cx->ref_max+1.0);
+
+#ifdef PLOT_DEBUG
+ if (cx->plot) {
+ xx[pix] = (double)i;
+ y1[pix] = yv;
+ y2[pix] = tp[0] * cx->wl_meas[i];
+// y3[pix] = 2000.0 * (0.02 + yv/cx->ref_max); /* Weighting */
+ y3[pix] = 0.5 * vv; /* Error squared */
+ pix++;
+ }
+#endif
+ rv += vv;
+ }
+#ifdef PLOT_DEBUG
+ if (cx->plot) {
+ printf("Params %f %f -> err %f\n", tp[0], tp[1], rv);
+ do_plot(xx, y1, y2, y3, pix);
+ }
+#endif
+//printf("~1 %f %f -> %f\n", tp[0], tp[1], rv);
+ return rv;
+}
+
+#ifdef SALONEINSTLIB
+/* Do a rudimetrary 2d optimization that uses exaustive */
+/* search with hierarchical step sizes */
+int wloptimize(double *cparm,
+ double *ss,
+ double tol,
+ double (*funk)(void *fdata, double tp[]),
+ void *fdata
+) {
+ double range[2][2]; /* [dim][min/max] */
+ double val[2]; /* Current test values */
+ double bfit = 1e38; /* Current best fit values */
+ int dim;
+
+ for (dim = 0; dim < 2; dim++) {
+ range[dim][0] = cparm[dim] - ss[dim];
+ range[dim][1] = cparm[dim] + ss[dim];
+ val[dim] = cparm[dim];
+ }
+
+ /* Until we reach the tollerance */
+ for (;;) {
+ double mstep = 1e38;
+
+ for (dim = 0; dim < 2; dim++) {
+ double stepsz;
+ stepsz = (range[dim][1] - range[dim][0])/10.0;
+ if (stepsz < mstep)
+ mstep = stepsz;
+
+ /* Search in this dimension */
+ for (val[dim] = range[dim][0]; val[dim] <= range[dim][1]; val[dim] += stepsz) {
+ double fit;
+ fit = funk(fdata, val);
+ if (fit < bfit) {
+ cparm[dim] = val[dim];
+ bfit = fit;
+ }
+ }
+ val[dim] = cparm[dim];
+ range[dim][0] = val[dim] - stepsz;
+ range[dim][1] = val[dim] + stepsz;
+ }
+ if (mstep <= tol)
+ break;
+ }
+ return 0;
+}
+#endif /* SALONEINSTLIB */
+
+
+/* Given a raw measurement of the wavelength LED, */
+/* Compute the base offset that best fits it to the reference */
+i1pro_code i1pro2_match_wl_meas(i1pro *p, double *pled_off, double *wlraw) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ int i;
+ int rpoff, mpoff; /* Peak offset */
+ int roff, moff; /* Base index */
+ double lhalf, rhalf;
+ double fwhm; /* Measured half width */
+ double rmax, mmax;
+ double magscale;
+ double led_off, off_nm;
+
+ /* Do simple match first - locate maximum */
+ rmax = -1e6;
+ rpoff = -1;
+ for (i = 0; i < m->wl_led_count; i++) {
+ if (m->wl_led_spec[i] > rmax) {
+ rmax = m->wl_led_spec[i]; /* Max of reference */
+ rpoff = i;
+ }
+ }
+
+ mmax = -1e6;
+ mpoff = -1;
+ for (i = 0; i < m->nraw; i++) {
+ if (wlraw[i] > mmax) {
+ mmax = wlraw[i]; /* Max of measurement */
+ mpoff = i;
+ }
+ }
+
+ if (mpoff < 0 || mpoff >= m->nraw) {
+ a1logd(p->log,1,"Couldn't locate WL measurement peak\n");
+ return I1PRO_WL_SHAPE;
+ }
+
+ /* Check magnitude is sufficient (not sure this is right, typically 5900 > 882) */
+ a1logd(p->log,2,"Measured WL level = %f, minimum needed = %f\n",mmax, m->wl_cal_min_level);
+ if (mmax < m->wl_cal_min_level) {
+ a1logd(p->log,1,"i1pro2_match_wl_meas peak magnitude too low\n");
+ return I1PRO_WL_TOOLOW;
+ }
+
+ /* Locate the half peak values */
+ for (i = 1; i < mpoff; i++) {
+ if (wlraw[i] > (mmax/2.0)) { /* Use linear interp */
+ lhalf = (wlraw[i] - mmax/2.0)/(wlraw[i] - wlraw[i-1]);
+ lhalf = lhalf * (i-1.0) + (1.0 - lhalf) * (double)i;
+ break;
+ }
+ }
+ if (i >= mpoff) {
+ a1logd(p->log,1,"Couldn't locate WL left half level\n");
+ return I1PRO_WL_SHAPE;
+ }
+ for (; i < m->nraw; i++) {
+ if (wlraw[i] < (mmax/2.0)) { /* Use linear interp */
+ rhalf = (mmax/2.0 - wlraw[i])/(wlraw[i-1] - wlraw[i]);
+ rhalf = rhalf * (i-1.0) + (1.0 - rhalf) * (double)i;
+ break;
+ }
+ }
+ if (i >= m->nraw) {
+ a1logd(p->log,1,"Couldn't locate WL righ half level\n");
+ return I1PRO_WL_SHAPE;
+ }
+ a1logd(p->log,5,"WL half levels at %f (%f nm) and %f (%f nm)\n",lhalf, i1pro_raw2wav_uncal(p, lhalf), rhalf, i1pro_raw2wav_uncal(p, rhalf));
+ fwhm = i1pro_raw2wav_uncal(p, lhalf) - i1pro_raw2wav_uncal(p, rhalf);
+ a1logd(p->log,3, "WL spectrum fwhm = %f\n",fwhm);
+ if (fwhm < (m->wl_cal_fwhm - m->wl_cal_fwhm_tol)
+ || fwhm > (m->wl_cal_fwhm + m->wl_cal_fwhm_tol)) {
+ a1logd(p->log,1,"WL fwhm %f is out of range %f .. %f\n",fwhm,m->wl_cal_fwhm - m->wl_cal_fwhm_tol,m->wl_cal_fwhm + m->wl_cal_fwhm_tol);
+ return I1PRO_WL_SHAPE;
+ }
+
+ roff = m->wl_led_ref_off; /* reference raw offset */
+ moff = mpoff - rpoff; /* rough measured raw offset */
+
+ a1logd(p->log,3, "Preliminary WL peak match at ref base offset %d into measurement\n", moff);
+
+ magscale = rmax/mmax; /* Initial scale to make them match */
+
+#ifdef PLOT_DEBUG
+ /* Plot the match */
+ {
+ double xx[1024];
+ double y1[1024];
+ double y2[1024];
+
+ for (i = 0; i < m->nraw; i++) {
+ xx[i] = (double)i;
+ y1[i] = 0.0;
+ if (i >= moff && (i - moff) < m->wl_led_count) {
+ y1[i] = m->wl_led_spec[i- moff];
+ }
+ y2[i] = wlraw[i] * magscale;
+ }
+ printf("Simple WL match, ref = black, meas = red:\n");
+ do_plot(xx, y1, y2, NULL, m->nraw);
+ }
+#endif
+
+ /* Now do a good match */
+ /*
+ Do Lagrange interpolation on the reference curve,
+ and use a minimizer to find the best fit (minimum weighted y error)
+ by optimizing the magnitude, offset and scale.
+ */
+
+ {
+ wlcal_cx cx;
+ double cparm[2]; /* fit parameters */
+ double ss[2]; /* Search range */
+
+ cparm[0] = magscale;
+ ss[0] = 0.2;
+ cparm[1] = (double)moff;
+ ss[1] = 4.0; /* == +- 12 nm */
+
+ cx.ref_max = rmax;
+ cx.wl_ref = m->wl_led_spec;
+ cx.wl_ref_n = m->wl_led_count;
+ cx.wl_meas = wlraw;
+ cx.wl_meas_n = m->nraw;
+// cx.plot = 1; /* Plot each trial */
+
+ /* We could use the scale to adjust the whole CCD range, */
+ /* but the manufacturers driver doesn't seem to do this, */
+ /* and it may be making the calibration sensitive to any */
+ /* changes in the WL LED spectrum shape. Instead we minimize */
+ /* the error weighted for the peak of the shape. */
+
+#ifdef SALONEINSTLIB
+ if (wloptimize(cparm, ss, 1e-7, wlcal_opt1, &cx))
+ a1logw(p->log,"wlcal_opt1 failed\n");
+#else
+ if (powell(NULL, 2, cparm, ss, 1e-6, 1000, wlcal_opt1, &cx, NULL, NULL))
+ a1logw(p->log,"wlcal_opt1 failed\n");
+#endif
+ a1logd(p->log,3,"WL best fit parameters: %f %f\n", cparm[0], cparm[1]);
+
+ led_off = cparm[1];
+
+#ifdef PLOT_DEBUG
+ /* Plot the final result */
+ printf("Best WL match, ref = black, meas = red, err = green:\n");
+ cx.plot = 1;
+ wlcal_opt1(&cx, cparm);
+#endif
+
+ /* If we have calibrated on the ambient cap, correct */
+ /* for the emissive vs. reflective raw2wav scaling factor */
+ if (mmax < 2500.0) {
+ double wlraw2 = m->wl_led_ref_off + (double)rpoff;
+ double raw, wlnm, wlraw1, refnm;
+ int k;
+
+ /* Convert from raw to wavelength using poly2 (emission) */
+ raw = 128.0 - wlraw2; /* Quadratic expects +ve correlation */
+ for (wlnm = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+ wlnm = wlnm * raw + m->wlpoly2[k];
+
+ /* Convert from wavelength to raw using poly1 (reflectance) */
+ wlraw1 = inv_raw2wav(m->wlpoly1, 4, wlnm);
+//printf("emiss raw %f -> ref raw %f\n",wlraw2, wlraw1);
+
+ /* Adjust the raw correction to account for measuring it in emissive mode */
+ led_off = led_off + wlraw2 - wlraw1;
+
+ /* Hmm. This is rather suspect. The difference between the white reference */
+ /* calibrated wavelength offset and the ambient cap one is about -0.2788 raw. */
+ /* This is not explained by the poly1 vs. poly2 difference at the WL LED peak */
+ /* at 550 nm. (see above), which amounts to about +0.026, leaving 0.2528 */
+ /* unexplained. It appears the CCD wavelength has a dependence on the */
+ /* angle that the light enters the optics ?? */
+
+ led_off += 0.2528; /* Hack to make ambient cap correction == white tile correction */
+
+ a1logd(p->log,3,"Adjusted raw correction by %f to account for measurement using ambient cap\n",wlraw2 - wlraw1 + 0.2528);
+ }
+
+ /* Check that the correction is not excessive */
+ off_nm = i1pro_raw2wav_uncal(p, led_off) - i1pro_raw2wav_uncal(p, m->wl_led_ref_off);
+ a1logd(p->log,2, "Final WL offset = %f, correction %f nm\n",led_off, off_nm);
+ if (fabs(off_nm)> m->wl_err_max) {
+ a1logd(p->log,1,"Final WL correction of %f nm is too big\n",off_nm);
+ return I1PRO_WL_ERR2BIG;
+ }
+
+ /* Do a verification plot */
+ /* Plot the measurement against calibrated wavelength, */
+ /* and reference measurement verses reference wavelength */
+
+#ifdef PLOT_DEBUG
+ {
+ double xx[1024];
+ double y1[1024]; /* interpolate ref */
+ double y2[1024]; /* Measurement */
+ int ii;
+
+ /* i = index into measurement */
+ for (ii = 0, i = m->wl_led_ref_off; i < (m->wl_led_ref_off + m->wl_led_count); i++) {
+ double raw;
+ double mwl; /* Measurment wavelength */
+ double rraw; /* Reference raw value */
+ int ix; /* Lagrange base offset */
+ int k;
+ double yv;
+
+ raw = (double)i;
+ raw = raw - led_off + m->wl_led_ref_off;
+ raw = 128.0 - raw; /* Quadratic expects +ve correlation */
+ if (mmax < 2500.0) {
+ for (mwl = m->wlpoly2[4-1], k = 4-2; k >= 0; k--)
+ mwl = mwl * raw + m->wlpoly2[k];
+ } else {
+ for (mwl = m->wlpoly1[4-1], k = 4-2; k >= 0; k--)
+ mwl = mwl * raw + m->wlpoly1[k];
+ }
+ xx[ii] = mwl;
+ y1[ii] = cparm[0] * wlraw[i];
+ y2[ii] = 0.0;
+
+ /* Compute the reference index corresponding to this wavelength */
+ rraw = inv_raw2wav(m->wlpoly1, 4, mwl) - (double)m->wl_led_ref_off;
+
+ /* Use Lagrange to interpolate the reference level for this wavelength */
+ ix = ((int)rraw) - 1; /* Reference index of Lagrange for this xv */
+ if (ix < 0)
+ continue;
+ if ((ix + 3) >= m->wl_led_count)
+ break;
+
+ /* Compute interpolated value of reference using Lagrange: */
+ yv = m->wl_led_spec[ix+0] * (rraw-(ix+1)) * (rraw-(ix+2)) * (rraw-(ix+3))
+ /((0.0-1.0) * (0.0-2.0) * (0.0-3.0))
+ + m->wl_led_spec[ix+1] * (rraw-(ix+0)) * (rraw-(ix+2)) * (rraw-(ix+3))
+ /((1.0-0.0) * (1.0-2.0) * (1.0-3.0))
+ + m->wl_led_spec[ix+2] * (rraw-(ix+0)) * (rraw-(ix+1)) * (rraw-(ix+3))
+ /((2.0-0.0) * (2.0-1.0) * (2.0-3.0))
+ + m->wl_led_spec[ix+3] * (rraw-(ix+0)) * (rraw-(ix+1)) * (rraw-(ix+2))
+ /((3.0-0.0) * (3.0-1.0) * (3.0-2.0));
+ y2[ii] = yv;
+ ii++;
+ }
+ printf("Verification fit in nm:\n");
+ do_plot(xx, y1, y2, NULL, ii);
+ }
+#endif
+
+ if (pled_off != NULL)
+ *pled_off = led_off;
+ }
+
+ return ev;
+}
+
+/* Compute standard res. downsampling filters for the given mode */
+/* given the current wl_led_off, and set them as current. */
+i1pro_code i1pro2_compute_wav_filters(i1pro *p, int refl) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ i1pro_code ev = I1PRO_OK;
+ double twidth; /* Target filter width */
+ int six, eix; /* raw starting index and one past end index */
+ int wlix; /* current wavelenght index */
+ double *wlcop; /* This wavelength base filter coefficient pointer */
+ double trh, trx; /* Triangle height and triangle equation x weighting */
+ int i, j, k;
+
+ a1logd(p->log,2,"i1pro2_compute_wav_filters called with correction %f raw\n",s->wl_led_off - m->wl_led_ref_off);
+
+ twidth = (m->wl_long[0] - m->wl_short[0])/(m->nwav[0] - 1.0); /* Filter width */
+
+ trh = 1.0/twidth; /* Triangle height */
+ trx = trh/twidth; /* Triangle equation x weighting */
+
+ /* Allocate separate space for the calibrated versions, so that the */
+ /* original eeprom values are preserved */
+ if (m->mtx_c[0][refl].index == NULL) {
+
+ if ((m->mtx_c[0][refl].index = (int *)calloc(m->nwav[0], sizeof(int))) == NULL) {
+ a1logd(p->log,1,"i1pro: malloc ndex1 failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ if ((m->mtx_c[0][refl].nocoef = (int *)calloc(m->nwav[0], sizeof(int))) == NULL) {
+ a1logd(p->log,1,"i1pro: malloc nocoef failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ if ((m->mtx_c[0][refl].coef = (double *)calloc(16 * m->nwav[0], sizeof(double)))
+ == NULL) {
+ a1logd(p->log,1,"i1pro: malloc coef failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+ }
+
+ /* For each output wavelength */
+ wlcop = m->mtx_c[0][refl].coef;
+ for (wlix = 0; wlix < m->nwav[0]; wlix++) {
+ double owl = wlix/(m->nwav[0]-1.0) * (m->wl_long[0] - m->wl_short[0]) + m->wl_short[0];
+ int lip; /* Lagrange interpolation position */
+
+// printf("Generating filter for %.1f nm width %.1f nm\n",owl, twidth);
+
+ /* The filter is based on a triangle centered at owl and extending */
+ /* from owl - twidth to owl + twidth. We therefore need to locate the */
+ /* raw values that will overlap this range */
+
+ /* Do a dumb search from high to low nm */
+ for (six = 0; six < m->nraw; six++) {
+ if (i1pro_raw2wav(p, refl, (double)six) < (owl + twidth))
+ break;
+ }
+ if (six < 2 || six >= m->nraw) {
+ a1loge(p->log,1,"i1pro: compute_wav_filters() six %d out of raw range to cover output filter %.1f nm width %.1f nm\n",six, owl, twidth);
+ return I1PRO_INT_ASSERT;
+ }
+ eix = six;
+ six -= 2; /* Outside */
+
+ for (; eix < m->nraw; eix++) {
+ if (i1pro_raw2wav(p, refl, (double)eix) <= (owl - twidth))
+ break;
+ }
+ if (eix > (m->nraw - 2) ) {
+ a1loge(p->log,1,"i1pro: compute_wav_filters() eix %d out of raw range to cover output filter %.1f nm width %.1f nm\n",eix, owl, twidth);
+ return I1PRO_INT_ASSERT;
+ }
+ eix += 2;
+
+// for (j = six; j < eix; j++)
+// printf("Using raw %d @ %.1f nm\n",j, i1pro_raw2wav(p, refl, (double)j));
+
+ /* Set start index for this wavelength */
+ m->mtx_c[0][refl].index[wlix] = six;
+
+ /* Set number of filter coefficients */
+ m->mtx_c[0][refl].nocoef[wlix] = eix - six;
+
+ if (m->mtx_c[0][refl].nocoef[wlix] > 16) {
+ a1loge(p->log,1,"i1pro: compute_wav_filters() too many filter %d\n",m->mtx_c[0][refl].nocoef[wlix]);
+ return I1PRO_INT_ASSERT;
+ }
+
+ /* Start with zero filter weightings */
+ for (i = 0; i < m->mtx_c[0][refl].nocoef[wlix]; i++)
+ wlcop[i] = 0.0;
+
+ /* for each Lagrange interpolation position */
+ for (lip = six; (lip + 3) < eix; lip++) {
+ double rwav[4]; /* Relative wavelength of these Lagrange points */
+ double den[4]; /* Denominator values for points */
+ double num[4][4]; /* Numerator polinomial components x^3, x^2, x, 1 */
+ double ilow, ihigh; /* Integration points */
+
+ /* Relative wavelengths to owl of each basis point */
+ for (i = 0; i < 4; i++)
+ rwav[i] = i1pro_raw2wav(p, refl, (double)lip + i) - owl;
+// printf("\n~1 rwav = %f %f %f %f\n", rwav[0], rwav[1], rwav[2], rwav[3]);
+
+ /* Compute each basis points Lagrange denominator values */
+ den[0] = (rwav[0]-rwav[1]) * (rwav[0]-rwav[2]) * (rwav[0]-rwav[3]);
+ den[1] = (rwav[1]-rwav[0]) * (rwav[1]-rwav[2]) * (rwav[1]-rwav[3]);
+ den[2] = (rwav[2]-rwav[0]) * (rwav[2]-rwav[1]) * (rwav[2]-rwav[3]);
+ den[3] = (rwav[3]-rwav[0]) * (rwav[3]-rwav[1]) * (rwav[3]-rwav[2]);
+// printf("~1 denominators = %f %f %f %f\n", den[0], den[1], den[2], den[3]);
+
+ /* Compute each basis points Langrange numerator components. */
+ /* We make the numerator have polinomial form, so that it is easy */
+ /* to compute the integral equation from it. */
+ num[0][0] = 1.0;
+ num[0][1] = -rwav[1] - rwav[2] - rwav[3];
+ num[0][2] = rwav[1] * rwav[2] + rwav[1] * rwav[3] + rwav[2] * rwav[3];
+ num[0][3] = -rwav[1] * rwav[2] * rwav[3];
+ num[1][0] = 1.0;
+ num[1][1] = -rwav[0] - rwav[2] - rwav[3];
+ num[1][2] = rwav[0] * rwav[2] + rwav[0] * rwav[3] + rwav[2] * rwav[3];
+ num[1][3] = -rwav[0] * rwav[2] * rwav[3];
+ num[2][0] = 1.0;
+ num[2][1] = -rwav[0] - rwav[1] - rwav[3];
+ num[2][2] = rwav[0] * rwav[1] + rwav[0] * rwav[3] + rwav[1] * rwav[3];
+ num[2][3] = -rwav[0] * rwav[1] * rwav[3];
+ num[3][0] = 1.0;
+ num[3][1] = -rwav[0] - rwav[1] - rwav[2];
+ num[3][2] = rwav[0] * rwav[1] + rwav[0] * rwav[2] + rwav[1] * rwav[2];
+ num[3][3] = -rwav[0] * rwav[1] * rwav[2];
+
+// printf("~1 num %d = %f %f %f %f\n", 0, num[0][0], num[0][1], num[0][2], num[0][3]);
+// printf("~1 num %d = %f %f %f %f\n", 1, num[1][0], num[1][1], num[1][2], num[1][3]);
+// printf("~1 num %d = %f %f %f %f\n", 2, num[2][0], num[2][1], num[2][2], num[2][3]);
+// printf("~1 num %d = %f %f %f %f\n", 3, num[3][0], num[3][1], num[3][2], num[3][3]);
+
+ /* Now compute the integral difference between the two middle points */
+ /* of the Lagrange over the triangle shape, and accumulate the resulting */
+ /* Lagrange weightings to the filter coefficients. */
+
+ /* For high and then low side of the triangle. */
+ for (k = 0; k < 2; k++) {
+
+ ihigh = rwav[1];
+ ilow = rwav[2];
+
+ if ((k == 0 && ilow <= twidth && ihigh >= 0.0) /* Portion is +ve side */
+ || (k == 1 && ilow <= 0.0 && ihigh >= -twidth)) { /* Portion is -ve side */
+
+ if (k == 0) {
+ if (ilow < 0.0)
+ ilow = 0.0;
+ if (ihigh > twidth)
+ ihigh = twidth;
+// printf("~1 doing +ve triangle between %f %f\n",ilow,ihigh);
+ } else {
+ if (ilow < -twidth)
+ ilow = -twidth;
+ if (ihigh > 0.0)
+ ihigh = 0.0;
+// printf("~1 doing -ve triangle between %f %f\n",ilow,ihigh);
+ }
+
+ /* For each Lagrange point */
+ for (i = 0; i < 4; i++) {
+ double xnum[5]; /* Expanded numerator components */
+ double nvall, nvalh; /* Numerator low and high values */
+
+ /* Because the y value is a function of x, we need to */
+ /* expand the Lagrange 3rd order polinomial into */
+ /* a 4th order polinomial using the triangle edge equation */
+ /* y = trh +- trx * x */
+ for (j = 0; j < 4; j++)
+ xnum[j] = (k == 0 ? -trx : trx) * num[i][j];
+ xnum[j] = 0.0;
+ for (j = 0; j < 4; j++)
+ xnum[j+1] += trh * num[i][j];
+
+ /* The 4th order equation becomes a 5th order one */
+ /* when we convert it to an integral, ie. x^4 becomes x^5/5 etc. */
+ for (j = 0; j < 4; j++)
+ xnum[j] /= (5.0 - (double)j); /* Integral denom. */
+
+ /* Compute ihigh integral as 5th order polynomial */
+ nvalh = xnum[0];
+ nvalh = nvalh * ihigh + xnum[1];
+ nvalh = nvalh * ihigh + xnum[2];
+ nvalh = nvalh * ihigh + xnum[3];
+ nvalh = nvalh * ihigh + xnum[4];
+ nvalh = nvalh * ihigh;
+
+ /* Compute ilow integral as 5th order polynomial */
+ nvall = xnum[0];
+ nvall = nvall * ilow + xnum[1];
+ nvall = nvall * ilow + xnum[2];
+ nvall = nvall * ilow + xnum[3];
+ nvall = nvall * ilow + xnum[4];
+ nvall = nvall * ilow;
+
+ /* Compute ihigh - ilow and add to filter weightings */
+ wlcop[lip -six + i] += (nvalh - nvall)/den[i];
+// printf("~1 k = %d, comp %d weight += %e now %e\n",k,lip-six+i,(nvalh - nvall)/den[i], wlcop[lip-six+i]);
+ }
+ }
+ }
+ }
+// printf("~1 Weightings for for %.1f nm are:\n",owl);
+// for (i = 0; i < m->mtx_c[0][refl].nocoef[wlix]; i++)
+// printf("~1 comp %d weight %e\n",i,wlcop[i]);
+
+ wlcop += m->mtx_c[0][refl].nocoef[wlix]; /* Next group of weightings */
+ }
+#ifdef DEBUG
+ /* Check against orginal filters */
+ {
+ int ix1, ix1c;
+ double aerr = 0.0;
+
+ a1logd(p->log,2,"Checking gemertated tables against EEProm table\n");
+ ix1 = ix1c = 0;
+ for (i = 0; i < m->nwav[0]; i++) {
+ double err;
+ int six, eix;
+
+ if (m->mtx_o.index[i] < m->mtx_o.index[i])
+ six = m->mtx_o.index[i];
+ else
+ six = m->mtx_o.index[i];
+
+ if ((m->mtx_o.index[i] + m->mtx_o.nocoef[i]) > (m->mtx_o.index[i] + m->mtx_o.nocoef[i]))
+ eix = m->mtx_o.index[i] + m->mtx_o.nocoef[i];
+ else
+ eix = m->mtx_o.index[i] + m->mtx_o.nocoef[i];
+// printf("~1 filter %d from %d to %d\n",i,six,eix);
+
+ err = 0.0;
+ for (j = six; j < eix; j++) {
+ double w1, w1c;
+
+ if (j < m->mtx_o.index[i] || j >= (m->mtx_o.index[i] + m->mtx_o.nocoef[i]))
+ w1 = 0.0;
+ else
+ w1 = m->mtx_o.coef[ix1 + j - m->mtx_o.index[i]];
+ if (j < m->mtx_c[0][refl].index[i]
+ || j >= (m->mtx_c[0][refl].index[i] + m->mtx_c[0][refl].nocoef[i]))
+ w1c = 0.0;
+ else
+ w1c = m->mtx_c[0][refl].coef[ix1c + j - m->mtx_c[0][refl].index[i]];
+
+ err += fabs(w1 - w1c);
+// printf("Weight %d, %e should be %e\n", j, w1c, w1);
+ }
+// printf("Filter %d average weighting error = %f\n",i, err/j);
+ aerr += err/j;
+
+ ix1 += m->mtx_o.nocoef[i];
+ ix1c += m->mtx_c[0][refl].nocoef[i];
+ }
+ a1logd(p->log,2,"Overall average filter weighting change = %f\n",aerr/m->nwav[0]);
+ }
+#endif /* DEBUG */
+
+ /* Switch normal res. to use wavelength calibrated version */
+ m->mtx[0][refl] = m->mtx_c[0][refl];
+
+ return ev;
+}
+
+
+/* =============================================== */
+#ifdef HIGH_RES
+
+#undef ANALIZE_EXISTING /* Analize the manufacturers existing filter shape */
+
+/* High res congiguration */
+/* Pick one of these: */
+#define USE_LANCZOS2 /* [def] Use lanczos2 filter shape */
+#undef USE_DECONV /* [und] Use deconvolution curve */
+#undef USE_GAUSSIAN /* [und] Use gaussian filter shape*/
+#undef USE_BLACKMAN /* [und] Use Blackman windowed sinc shape */
+#undef USE_CUBIC /* [und] Use cubic spline filter */
+
+#undef COMPUTE_DISPERSION /* Compute slit & optics dispersion from red laser data */
+
+#ifdef NEVER
+/* Plot the matrix coefficients */
+static void i1pro_debug_plot_mtx_coef(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ int i, j, k, cx, sx;
+ double *xx, *ss;
+ double **yy;
+
+ xx = dvectorz(-1, m->nraw-1); /* X index */
+ yy = dmatrixz(0, 5, -1, m->nraw-1); /* Curves distributed amongst 5 graphs */
+
+ for (i = 0; i < m->nraw; i++)
+ xx[i] = i;
+
+ /* For each output wavelength */
+ for (cx = j = 0; j < m->nwav; j++) {
+ i = j % 5;
+
+// printf("Out wave = %d\n",j);
+ /* For each matrix value */
+ sx = m->mtx_index[j]; /* Starting index */
+// printf("start index = %d, nocoef %d\n",sx,m->mtx_nocoef[j]);
+ for (k = 0; k < m->mtx_nocoef[j]; k++, cx++, sx++) {
+// printf("offset %d, coef ix %d val %f from ccd %d\n",k, cx, m->mtx_coef[cx], sx);
+ yy[5][sx] += 0.5 * m->mtx_coef[cx];
+ yy[i][sx] = m->mtx_coef[cx];
+ }
+ }
+
+ do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+ free_dvector(xx, -1, m->nraw-1);
+ free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+}
+#endif
+
+#ifdef COMPUTE_DISPERSION
+
+/* Gausian filter implementation */
+/* parameters are amplidude [0], center wavelength [1], std. dev. [2] */
+static double gaussf(double tp[], double x) {
+ double y;
+
+ x = (x - tp[1])/(sqrt(2.0) * tp[2]);
+ y = tp[0] * exp(-(x * x));
+
+ return y;
+}
+
+/* Gausian integral implementatation */
+/* parameters are amplidude [0], center wavelength [1], std. dev. [2] */
+/* return an aproximation to the intergral between w1 and w2 */
+static double gaussint(double tp[], double w1, double w2) {
+ int j, nn;
+ double lw, ll, vv;
+
+ /* Intergate in 0.1 nm increments */
+ nn = (int)(fabs(w2 - w1)/0.1 + 0.5);
+
+ lw = w1;
+ ll = gaussf(tp, lw);
+ vv = 0.0;
+ for (j = 0; j < nn; j++) {
+ double cw, cl;
+ cw = w1 + (j+1)/(nn +1.0) * (w2 - w1);
+ cl = gaussf(tp, cw);
+ vv += 0.5 * (cl + ll) * (lw - cw);
+ ll = cl;
+ lw = cw;
+ }
+ return fabs(vv);
+}
+
+/* Powell minimisation context */
+typedef struct {
+ double nsp; /* Number of samples of dispersion data */
+ double *llv; /* [nsamp] laser values */
+ double *lwl; /* [nsamp+1] CCD boundary wavelegths */
+} hropt_cx;
+
+/* Powell minimisation callback function */
+/* to match dispersion data */
+static double hropt_opt1(void *vcx, double tp[]) {
+ hropt_cx *cx = (hropt_cx *)vcx;
+ double rv = 0.0;
+ int i, j;
+
+ /* For each CCD sample */
+ for (i = 0; i < cx->nsp; i++) {
+ double vv;
+
+ /* Actual CCD integrated value */
+ vv = cx->llv[i] * (cx->lwl[i] - cx->lwl[i+1]);
+ /* Computed intergral with current curve */
+ vv -= gaussint(tp, cx->lwl[i], cx->lwl[i+1]);
+ rv += vv * vv;
+ }
+// printf("~1 params %f %f %f, rv = %f\n", tp[0],tp[1],tp[2],rv);
+ return rv;
+}
+
+#endif /* COMPUTE_DISPERSION */
+
+/* Filter shape point */
+typedef struct {
+ double wl, we;
+} i1pro_fs;
+
+/* Filter cooeficient values */
+typedef struct {
+ int ix; /* Raw index */
+ double we; /* Weighting */
+} i1pro_fc;
+
+/* Wavelenth calibration crossover point information */
+typedef struct {
+ double wav; /* Wavelegth of point */
+ double raw; /* Raw index of point */
+ double wei; /* Weigting of the point */
+} i1pro_xp;
+
+/* Linearly interpolate the filter shape */
+static double lin_fshape(i1pro_fs *fsh, int n, double x) {
+ int i;
+ double y;
+
+ if (x <= fsh[0].wl)
+ return fsh[0].we;
+ else if (x >= fsh[n-1].wl)
+ return fsh[n-1].we;
+
+ for (i = 0; i < (n-2); i++)
+ if (x >= fsh[i].wl && x <= fsh[i+1].wl)
+ break;
+
+ x = (x - fsh[i].wl)/(fsh[i+1].wl - fsh[i].wl);
+ y = fsh[i].we + (fsh[i+1].we - fsh[i].we) * x;
+
+ return y;
+}
+
+/* Generate a sample from a lanczos2 filter shape */
+/* wi is the width of the filter */
+static double lanczos2(double wi, double x) {
+ double y;
+
+#ifdef USE_DECONV
+ /* For 3.333, created by i1deconv.c */
+ static i1pro_fs fshape[49] = {
+ { -7.200000, 0.0 },
+ { -6.900000, 0.013546 },
+ { -6.600000, 0.035563 },
+ { -6.300000, 0.070500 },
+ { -6.000000, 0.106543 },
+ { -5.700000, 0.148088 },
+ { -5.400000, 0.180888 },
+ { -5.100000, 0.186637 },
+ { -4.800000, 0.141795 },
+ { -4.500000, 0.046101 },
+ { -4.200000, -0.089335 },
+ { -3.900000, -0.244652 },
+ { -3.600000, -0.391910 },
+ { -3.300000, -0.510480 },
+ { -3.000000, -0.573177 },
+ { -2.700000, -0.569256 },
+ { -2.400000, -0.489404 },
+ { -2.100000, -0.333957 },
+ { -1.800000, -0.116832 },
+ { -1.500000, 0.142177 },
+ { -1.200000, 0.411639 },
+ { -0.900000, 0.658382 },
+ { -0.600000, 0.851521 },
+ { -0.300000, 0.967139 },
+ { 0.000000, 1.000000 },
+ { 0.300000, 0.967139 },
+ { 0.600000, 0.851521 },
+ { 0.900000, 0.658382 },
+ { 1.200000, 0.411639 },
+ { 1.500000, 0.142177 },
+ { 1.800000, -0.116832 },
+ { 2.100000, -0.333957 },
+ { 2.400000, -0.489404 },
+ { 2.700000, -0.569256 },
+ { 3.000000, -0.573177 },
+ { 3.300000, -0.510480 },
+ { 3.600000, -0.391910 },
+ { 3.900000, -0.244652 },
+ { 4.200000, -0.089335 },
+ { 4.500000, 0.046101 },
+ { 4.800000, 0.141795 },
+ { 5.100000, 0.186637 },
+ { 5.400000, 0.180888 },
+ { 5.700000, 0.148088 },
+ { 6.000000, 0.106543 },
+ { 6.300000, 0.070500 },
+ { 6.600000, 0.035563 },
+ { 6.900000, 0.013546 },
+ { 7.200000, 0.0 }
+ };
+
+ return lin_fshape(fshape, 49, x);
+#endif
+
+#ifdef USE_GAUSSIAN
+ /* gausian */
+ wi = wi/(2.0 * sqrt(2.0 * log(2.0))); /* Convert width at half max to std. dev. */
+ x = x/(sqrt(2.0) * wi);
+// y = 1.0/(wi * sqrt(2.0 * DBL_PI)) * exp(-(x * x)); /* Unity area */
+ y = exp(-(x * x)); /* Center at 1.0 */
+#endif
+
+#ifdef USE_LANCZOS2
+ /* lanczos2 */
+ x = fabs(1.0 * x/wi);
+ if (x >= 2.0)
+ return 0.0;
+ if (x < 1e-5)
+ return 1.0;
+ y = sin(DBL_PI * x)/(DBL_PI * x) * sin(DBL_PI * x/2.0)/(DBL_PI * x/2.0);
+#endif
+
+#ifdef USE_BLACKMAN /* Use Blackman windowed sinc shape */
+ double xx = x, w;
+ double a0, a1, a2, a3;
+ double bb, cc;
+
+ xx = fabs(1.0 * x/wi);
+ if (xx >= 2.0)
+ return 0.0;
+ if (xx < 1e-5)
+ return 1.0;
+ y = sin(DBL_PI * xx)/(DBL_PI * xx); /* sinc */
+
+ /* gausian window */
+// wi *= 1.5;
+// wi = wi/(2.0 * sqrt(2.0 * log(2.0))); /* Convert width at half max to std. dev. */
+// x = x/(sqrt(2.0) * wi);
+// w = exp(-(x * x));
+
+ xx = (xx/4.0 + 0.5); /* Convert to standard window cos() range */
+
+ /* Hamming window */
+// a0 = 0.54; a1 = 0.46;
+// w = a0 - a1 * cos(2.0 * DBL_PI * xx);
+
+ /* Blackman window */
+ a0 = 7938.0/18608.0; a1 = 9240.0/18608.0; a2 = 1430.0/18608.0;
+ w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx);
+
+ /* Nuttall window */
+// a0 = 0.355768; a1=0.487396; a2=0.144232; a3=0.012604;
+// w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx) - a3 * cos(6.0 * DBL_PI * xx);
+
+ /* Blackman Harris window */
+// a0=0.35875; a1=0.48829; a2=0.14128; a3=0.01168;
+// w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx) - a3 * cos(6.0 * DBL_PI * xx);
+
+ /* Blackman Nuttall window */
+// a0=0.3635819; a1=0.4891775; a2=0.1365995; a3=0.0106411;
+// w = a0 - a1 * cos(2.0 * DBL_PI * xx) + a2 * cos(4.0 * DBL_PI * xx) - a3 * cos(6.0 * DBL_PI * xx);
+
+ y *= w;
+#endif
+#ifdef USE_CUBIC /* Use cubic sline */
+ double xx = x;
+ double bb, cc;
+
+ xx = fabs(1.0 * x/wi);
+
+// bb = cc = 1.0/3.0; /* Mitchell */
+ bb = 0.5;
+ cc = 0.5;
+ xx *= 1.2;
+
+ if (xx < 1.0) {
+ y = ( 12.0 - 9.0 * bb - 6.0 * cc) * xx * xx * xx
+ + (-18.0 + 12.0 * bb + 6.0 * cc) * xx * xx
+ + ( 6.0 - 2.0 * bb);
+ y /= (6.0 - 2.0 * bb);
+ } else if (xx < 2.0) {
+ y = ( -1.0 * bb - 6.0 * cc) * xx * xx * xx
+ + ( 6.0 * bb + 30.0 * cc) * xx * xx
+ + (-12.0 * bb - 48.0 * cc) * xx
+ + ( 8.0 * bb + 24.0 * cc);
+ y /= (6.0 - 2.0 * bb);
+ } else {
+ y = 0.0;
+ }
+#endif
+ return y;
+}
+
+#if defined(__APPLE__) && defined(__POWERPC__)
+
+/* Workaround for a ppc gcc 3.3 optimiser bug... */
+static int gcc_bug_fix(int i) {
+ static int nn;
+ nn += i;
+ return nn;
+}
+#endif /* APPLE */
+
+/* Create or re-create high resolution mode references */
+i1pro_code i1pro_create_hr(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+ int refl;
+ int i, j, k, cx, sx;
+
+ /* If we don't have any way of converting raw2wav (ie. RevE polinomial equations), */
+ /* use the orginal filters to figure this out. */
+ if (p->itype != instI1Pro2 && m->raw2wav == NULL) {
+ i1pro_fc coeff[100][16]; /* Existing filter cooefficients */
+ i1pro_xp xp[101]; /* Crossover points each side of filter */
+ i1pro_fs fshape[100 * 16]; /* Existing filter shape */
+ int ncp = 0; /* Number of shape points */
+
+ /* Convert the native filter cooeficient representation to */
+ /* a 2D array we can randomly index. */
+ for (cx = j = 0; j < m->nwav[0]; j++) { /* For each output wavelength */
+ if (j >= 100) { /* Assert */
+ a1loge(p->log,1,"i1pro: number of output wavelenths is > 100\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ /* For each matrix value */
+ sx = m->mtx_o.index[j]; /* Starting index */
+ for (k = 0; k < m->mtx_o.nocoef[j]; k++, cx++, sx++) {
+ if (k >= 16) { /* Assert */
+ a1loge(p->log,1,"i1pro: number of filter coeefs is > 16\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ coeff[j][k].ix = sx;
+ coeff[j][k].we = m->mtx_o.coef[cx];
+// printf("Output %d, filter %d weight = %e\n",j,k,coeff[j][k].we);
+ }
+ }
+
+#ifdef HIGH_RES_PLOT
+ /* Plot original re-sampling curves */
+ {
+ double *xx, *ss;
+ double **yy;
+
+ xx = dvectorz(-1, m->nraw-1); /* X index */
+ yy = dmatrixz(0, 5, -1, m->nraw-1); /* Curves distributed amongst 5 graphs */
+
+ for (i = 0; i < m->nraw; i++)
+ xx[i] = i;
+
+ /* For each output wavelength */
+ for (j = 0; j < m->nwav[0]; j++) {
+ i = j % 5;
+
+ /* For each matrix value */
+ for (k = 0; k < m->mtx_o.nocoef[j]; k++) {
+ yy[5][coeff[j][k].ix] += 0.5 * coeff[j][k].we;
+ yy[i][coeff[j][k].ix] = coeff[j][k].we;
+ }
+ }
+
+ printf("Original wavelength sampling curves:\n");
+ do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+ free_dvector(xx, -1, m->nraw-1);
+ free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+ }
+#endif /* HIGH_RES_PLOT */
+
+ /* Compute the crossover points between each filter */
+ for (i = 0; i < (m->nwav[0]-1); i++) {
+ double den, y1, y2, y3, y4, yn, xn; /* Location of intersection */
+
+ /* between filter i and i+1, we want to find the two */
+ /* raw indexes where the weighting values cross over */
+ /* Do a brute force search to avoid making assumptions */
+ /* about the raw order */
+ for (j = 0; j < (m->mtx_o.nocoef[i]-1); j++) {
+ for (k = 0; k < (m->mtx_o.nocoef[i+1]-1); k++) {
+// printf("~1 checking %d, %d: %d = %d, %d = %d\n",j,k, coeff[i][j].ix, coeff[i+1][k].ix, coeff[i][j+1].ix, coeff[i+1][k+1].ix);
+ if (coeff[i][j].ix == coeff[i+1][k].ix
+ && coeff[i][j+1].ix == coeff[i+1][k+1].ix
+ && coeff[i][j].we > 0.0 && coeff[i][j+1].we > 0.0
+ && coeff[i][k].we > 0.0 && coeff[i][k+1].we > 0.0
+ && (( coeff[i][j].we >= coeff[i+1][k].we
+ && coeff[i][j+1].we <= coeff[i+1][k+1].we)
+ || ( coeff[i][j].we <= coeff[i+1][k].we
+ && coeff[i][j+1].we >= coeff[i+1][k+1].we))) {
+// printf("~1 got it at %d, %d: %d = %d, %d = %d\n",j,k, coeff[i][j].ix, coeff[i+1][k].ix, coeff[i][j+1].ix, coeff[i+1][k+1].ix);
+ goto gotit;
+ }
+ }
+ }
+ gotit:;
+ if (j >= m->mtx_o.nocoef[i]) { /* Assert */
+ a1loge(p->log,1,"i1pro: failed to locate crossover between resampling filters\n");
+ return I1PRO_INT_ASSERT;
+ }
+// printf("~1 %d: overlap at %d, %d: %f : %f, %f : %f\n",i, j,k, coeff[i][j].we, coeff[i+1][k].we, coeff[i][j+1].we, coeff[i+1][k+1].we);
+
+ /* Compute the intersection of the two line segments */
+ y1 = coeff[i][j].we;
+ y2 = coeff[i][j+1].we;
+ y3 = coeff[i+1][k].we;
+ y4 = coeff[i+1][k+1].we;
+ den = -y4 + y3 + y2 - y1;
+ yn = (y2 * y3 - y1 * y4)/den;
+ xn = (y3 - y1)/den;
+// printf("~1 den = %f, yn = %f, xn = %f\n",den,yn,xn);
+ xp[i+1].wav = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i + 0.5);
+ xp[i+1].raw = (1.0 - xn) * coeff[i][j].ix + xn * coeff[i][j+1].ix;
+ xp[i+1].wei = yn;
+// printf("Intersection %d: wav %f, raw %f, wei %f\n",i+1,xp[i+1].wav,xp[i+1].raw,xp[i+1].wei);
+// printf("\n");
+ }
+
+ /* Add the two points for the end filters */
+ {
+ double x5, x6, y5, y6; /* Points on intesecting line */
+ double den, y1, y2, y3, y4, yn, xn; /* Location of intersection */
+
+ x5 = xp[1].raw;
+ y5 = xp[1].wei;
+ x6 = xp[2].raw;
+ y6 = xp[2].wei;
+
+ /* Search for possible intersection point with first curve */
+ /* Create equation for line from next two intersection points */
+ for (j = 0; j < (m->mtx_o.nocoef[0]-1); j++) {
+ /* Extrapolate line to this segment */
+ y3 = y5 + (coeff[0][j].ix - x5)/(x6 - x5) * (y6 - y5);
+ y4 = y5 + (coeff[0][j+1].ix - x5)/(x6 - x5) * (y6 - y5);
+ /* This segment of curve */
+ y1 = coeff[0][j].we;
+ y2 = coeff[0][j+1].we;
+ if ( (( y1 >= y3 && y2 <= y4) /* Segments overlap */
+ || ( y1 <= y3 && y2 >= y4))
+ && (( coeff[0][j].ix < x5 && coeff[0][j].ix < x6
+ && coeff[0][j+1].ix < x5 && coeff[0][j+1].ix < x6)
+ || ( coeff[0][j+1].ix > x5 && coeff[0][j+1].ix > x6
+ && coeff[0][j].ix > x5 && coeff[0][j].ix > x6))) {
+ break;
+ }
+ }
+ if (j >= m->mtx_o.nocoef[0]) { /* Assert */
+ a1loge(p->log,1,"i1pro: failed to end crossover\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ den = -y4 + y3 + y2 - y1;
+ yn = (y2 * y3 - y1 * y4)/den;
+ xn = (y3 - y1)/den;
+// printf("~1 den = %f, yn = %f, xn = %f\n",den,yn,xn);
+ xp[0].wav = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], -0.5);
+ xp[0].raw = (1.0 - xn) * coeff[0][j].ix + xn * coeff[0][j+1].ix;
+ xp[0].wei = yn;
+// printf("End 0 intersection %d: wav %f, raw %f, wei %f\n",0,xp[0].wav,xp[0].raw,xp[0].wei);
+// printf("\n");
+
+ x5 = xp[m->nwav[0]-2].raw;
+ y5 = xp[m->nwav[0]-2].wei;
+ x6 = xp[m->nwav[0]-1].raw;
+ y6 = xp[m->nwav[0]-1].wei;
+
+// printf("~1 x5 %f, y5 %f, x6 %f, y6 %f\n",x5,y5,x6,y6);
+ /* Search for possible intersection point with first curve */
+ /* Create equation for line from next two intersection points */
+ for (j = 0; j < (m->mtx_o.nocoef[0]-1); j++) {
+ /* Extrapolate line to this segment */
+ y3 = y5 + (coeff[m->nwav[0]-1][j].ix - x5)/(x6 - x5) * (y6 - y5);
+ y4 = y5 + (coeff[m->nwav[0]-1][j+1].ix - x5)/(x6 - x5) * (y6 - y5);
+ /* This segment of curve */
+ y1 = coeff[m->nwav[0]-1][j].we;
+ y2 = coeff[m->nwav[0]-1][j+1].we;
+ if ( (( y1 >= y3 && y2 <= y4) /* Segments overlap */
+ || ( y1 <= y3 && y2 >= y4))
+ && (( coeff[m->nwav[0]-1][j].ix < x5 && coeff[m->nwav[0]-1][j].ix < x6
+ && coeff[m->nwav[0]-1][j+1].ix < x5 && coeff[m->nwav[0]-1][j+1].ix < x6)
+ || ( coeff[m->nwav[0]-1][j+1].ix > x5 && coeff[m->nwav[0]-1][j+1].ix > x6
+ && coeff[m->nwav[0]-1][j].ix > x5 && coeff[m->nwav[0]-1][j].ix > x6))) {
+ break;
+ }
+ }
+ if (j >= m->mtx_o.nocoef[m->nwav[0]-1]) { /* Assert */
+ a1loge(p->log,1,"i1pro: failed to end crossover\n");
+ return I1PRO_INT_ASSERT;
+ }
+ den = -y4 + y3 + y2 - y1;
+ yn = (y2 * y3 - y1 * y4)/den;
+ xn = (y3 - y1)/den;
+// printf("~1 den = %f, yn = %f, xn = %f\n",den,yn,xn);
+ xp[m->nwav[0]].wav = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], m->nwav[0]-0.5);
+ xp[m->nwav[0]].raw = (1.0 - xn) * coeff[m->nwav[0]-1][j].ix + xn * coeff[m->nwav[0]-1][j+1].ix;
+ xp[m->nwav[0]].wei = yn;
+// printf("End 36 intersection %d: wav %f, raw %f, wei %f\n",m->nwav[0]+1,xp[m->nwav[0]].wav,xp[m->nwav[0]].raw,xp[m->nwav[0]].wei);
+// printf("\n");
+ }
+
+#ifdef HIGH_RES_DEBUG
+ /* Check to see if the area of each filter curve is the same */
+ /* (yep, width times 2 * xover height is close to 1.0, and the */
+ /* sum of the weightings is exactly 1.0) */
+ for (i = 0; i < m->nwav[0]; i++) {
+ double area1, area2;
+ area1 = fabs(xp[i].raw - xp[i+1].raw) * (xp[i].wei + xp[i+1].wei);
+
+ area2 = 0.0;
+ for (j = 0; j < (m->mtx_o.nocoef[i]); j++)
+ area2 += coeff[i][j].we;
+
+ printf("Area of curve %d = %f, %f\n",i,area1, area2);
+ }
+#endif /* HIGH_RES_DEBUG */
+
+ /* From our crossover data, create a rspl that maps raw CCD index */
+ /* value into wavelegth. */
+ {
+ co sd[101]; /* Scattered data points */
+ datai glow, ghigh;
+ datao vlow, vhigh;
+ int gres[1];
+ double avgdev[1];
+
+ if ((m->raw2wav = new_rspl(RSPL_NOFLAGS, 1, 1)) == NULL) {
+ a1logd(p->log,1,"i1pro: creating rspl for high res conversion failed\n");
+ return I1PRO_INT_NEW_RSPL_FAILED;
+ }
+
+ vlow[0] = 1e6;
+ vhigh[0] = -1e6;
+ for (i = 0; i < (m->nwav[0]+1); i++) {
+ sd[i].p[0] = xp[i].raw;
+ sd[i].v[0] = xp[i].wav;
+
+ if (sd[i].v[0] < vlow[0])
+ vlow[0] = sd[i].v[0];
+ if (sd[i].v[0] > vhigh[0])
+ vhigh[0] = sd[i].v[0];
+ }
+ glow[0] = 0.0;
+ ghigh[0] = 127.0;
+ gres[0] = 128;
+ avgdev[0] = 0.0;
+
+ m->raw2wav->fit_rspl(m->raw2wav, 0, sd, m->nwav[0]+1, glow, ghigh, gres, vlow, vhigh, 0.5, avgdev, NULL);
+
+#ifdef HIGH_RES_PLOT
+ /* Plot raw to wav lookup */
+ {
+ double *xx, *yy, *y2;
+
+ xx = dvector(0, m->nwav[0]+1); /* X index = raw bin */
+ yy = dvector(0, m->nwav[0]+1); /* Y = nm */
+ y2 = dvector(0, m->nwav[0]+1); /* Y = nm */
+
+ for (i = 0; i < (m->nwav[0]+1); i++) {
+ co pp;
+ double iv, v1, v2;
+ xx[i] = xp[i].raw;
+ yy[i] = xp[i].wav;
+
+ pp.p[0] = xp[i].raw;
+ m->raw2wav->interp(m->raw2wav, &pp);
+ y2[i] = pp.v[0];
+ }
+
+ printf("CCD bin to wavelength mapping of original filters + rspl:\n");
+ do_plot6(xx, yy, y2, NULL, NULL, NULL, NULL, m->nwav+1);
+ free_dvector(xx, 0, m->nwav[0]+1);
+ free_dvector(yy, 0, m->nwav[0]+1);
+ free_dvector(y2, 0, m->nwav[0]+1);
+ }
+#endif /* HIGH_RES_PLOT */
+ }
+ }
+
+#ifdef ANALIZE_EXISTING
+ /* Convert each weighting curves values into normalized values and */
+ /* accumulate into a single curve. */
+ if (!m->hr_inited) {
+ for (i = 0; i < m->nwav[0]; i++) {
+ double cwl; /* center wavelegth */
+ double weight = 0.0;
+
+ for (j = 0; j < (m->mtx_o.nocoef[i]); j++) {
+ double w1, w2, cellw;
+
+ /* Translate CCD cell boundaries index to wavelength */
+ w1 = i1pro_raw2wav_uncal(p, (double)coeff[i][j].ix - 0.5);
+
+ w2 = i1pro_raw2wav_uncal(p, (double)coeff[i][j].ix + 0.5);
+
+ cellw = fabs(w2 - w1);
+
+ cwl = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i);
+
+ /* Translate CCD index to wavelength */
+ fshape[ncp].wl = i1pro_raw2wav_uncal(p, (double)coeff[i][j].ix) - cwl;
+ fshape[ncp].we = coeff[i][j].we / (0.09 * cellw);
+ ncp++;
+ }
+ }
+
+ /* Now sort by wavelength */
+#define HEAP_COMPARE(A,B) (A.wl < B.wl)
+ HEAPSORT(i1pro_fs, fshape, ncp)
+#undef HEAP_COMPARE
+
+ /* Strip out leading zero's */
+ for (i = 0; i < ncp; i++) {
+ if (fshape[i].we != 0.0)
+ break;
+ }
+ if (i > 1 && i < ncp) {
+ memmove(&fshape[0], &fshape[i-1], sizeof(i1pro_fs) * (ncp - i + 1));
+ ncp = ncp - i + 1;
+ for (i = 0; i < ncp; i++) {
+ if (fshape[i].we != 0.0)
+ break;
+ }
+ }
+
+#ifdef HIGH_RES_PLOT
+ /* Plot the shape of the accumulated curve */
+ {
+ double *x1 = dvectorz(0, ncp-1);
+ double *y1 = dvectorz(0, ncp-1);
+
+ for (i = 0; i < ncp; i++) {
+ double x;
+ x1[i] = fshape[i].wl;
+ y1[i] = fshape[i].we;
+ }
+ printf("Accumulated curve:\n");
+ do_plot(x1, y1, NULL, NULL, ncp);
+
+ free_dvector(x1, 0, ncp-1);
+ free_dvector(y1, 0, ncp-1);
+ }
+#endif /* HIGH_RES_PLOT */
+
+#ifdef HIGH_RES_DEBUG
+ /* Check that the orginal filter sums to a constant */
+ {
+ double x, sum;
+
+ for (x = 0.0; x < 10.0; x += 0.2) {
+ sum = 0;
+ sum += lin_fshape(fshape, ncp, x - 30.0);
+ sum += lin_fshape(fshape, ncp, x - 20.0);
+ sum += lin_fshape(fshape, ncp, x - 10.0);
+ sum += lin_fshape(fshape, ncp, x - 0.0);
+ sum += lin_fshape(fshape, ncp, x + 10.0);
+ sum += lin_fshape(fshape, ncp, x + 20.0);
+ printf("Offset %f, sum %f\n",x, sum);
+ }
+ }
+#endif /* HIGH_RES_DEBUG */
+ }
+#endif /* ANALIZE_EXISTING */
+
+#ifdef COMPUTE_DISPERSION
+ if (!m->hr_inited) {
+ /* Fit our red laser CCD data to a slit & optics Gaussian dispersion model */
+ {
+ double spf[3]; /* Spread function parameters */
+
+ /* Measured CCD values of red laser from CCD indexes 29 to 48 inclusive */
+ /* (It would be nice to have similar data from a monochromic source */
+ /* at other wavelegths such as green and blue!) */
+ double llv[20] = {
+ 53.23,
+ 81.3,
+ 116.15,
+ 176.16,
+ 305.87,
+ 613.71,
+ 8500.52,
+ 64052.0,
+ 103134.13,
+ 89154.03,
+ 21742.89,
+ 1158.86,
+ 591.44,
+ 369.75,
+ 241.01,
+ 166.48,
+ 126.79,
+ 97.76,
+ 63.88,
+ 46.46
+ };
+ double lwl[21]; /* Wavelegth of boundary between CCD cells */
+ double ccd;
+ hropt_cx cx;
+ double ss[3];
+
+ /* Add CCD boundary wavelengths to dispersion data */
+ for (ccd = 29.0 - 0.5, i = 0; i < 21; i++, ccd += 1.0) {
+ /* Translate CCD cell boundaries index to wavelength */
+ lwl[i] = i1pro_raw2wav_uncal(p, ccd);
+ }
+
+ /* Fit a gausian to it */
+ cx.nsp = 20;
+ cx.llv = llv;
+ cx.lwl = lwl;
+
+ /* parameters are amplidude [0], center wavelength [1], std. dev. [2] */
+ spf[0] = 115248.0;
+ spf[1] = 653.78;
+ spf[2] = 3.480308;
+ ss[0] = 500.0;
+ ss[1] = 0.5;
+ ss[2] = 0.5;
+
+ if (powell(NULL, 3, spf, ss, 1e-5, 2000, hropt_opt1, &cx))
+ a1logw(p->log,"hropt_opt1 failed\n");
+
+#ifdef HIGH_RES_PLOT
+ /* Plot dispersion spectra */
+ {
+ double xx[200];
+ double y1[200];
+ double y2[200];
+ double w1, w2;
+
+ w1 = lwl[0] + 5.0;
+ w2 = lwl[20] - 5.0;
+ for (i = 0; i < 200; i++) {
+ double wl;
+ wl = w1 + (i/199.0) * (w2-w1);
+ xx[i] = wl;
+ for (j = 0; j < 20; j++) {
+ if (lwl[j] >= wl && wl >= lwl[j+1])
+ break;
+ }
+ if (j < 20)
+ y1[i] = llv[j];
+ else
+ y1[i] = 0.0;
+ y2[i] = gaussf(spf, wl);
+ }
+ printf("Gauss Parameters %f %f %f\n",spf[0],spf[1],spf[2]);
+ printf("Red laser dispersion data:\n");
+ do_plot(xx, y1, y2, NULL, 200);
+ }
+#endif /* HIGH_RES_PLOT */
+
+ /* Normalize the gausian to have an area of 1 */
+ spf[0] *= 1.0/(spf[0] * spf[2] * sqrt(2.0 * DBL_PI));
+
+// printf("~1 Normalized intergral = %f\n",gaussint(spf, spf[1] - 30.0, spf[1] + 30.0));
+// printf("~1 Half width = %f\n",2.0 * sqrt(2.0 * log(2.0)) * spf[2]);
+ }
+ }
+#endif /* COMPUTE_DISPERSION */
+
+ /* Compute the upsampled calibration references */
+ if (!m->hr_inited) {
+ rspl *trspl; /* Upsample rspl */
+ cow sd[40 * 40]; /* Scattered data points of existing references */
+ datai glow, ghigh;
+ datao vlow, vhigh;
+ int gres[2];
+ double avgdev[2];
+ int ii;
+ co pp;
+
+ if ((trspl = new_rspl(RSPL_NOFLAGS, 1, 1)) == NULL) {
+ a1logd(p->log,1,"i1pro: creating rspl for high res conversion failed\n");
+ return I1PRO_INT_NEW_RSPL_FAILED;
+ }
+
+ for (ii = 0; ii < 3; ii++) {
+ double **ref2, *ref1;
+ double smooth = 1.0;
+
+ if (ii == 0) {
+ ref1 = m->white_ref[0];
+ ref2 = &m->white_ref[1];
+ smooth = 0.5;
+ } else if (ii == 1) {
+ ref1 = m->emis_coef[0];
+ ref2 = &m->emis_coef[1];
+ smooth = 500.0; /* Hmm. Lagrange may work better ?? */
+ } else {
+ if (m->amb_coef[0] == NULL)
+ break;
+ ref1 = m->amb_coef[0];
+ ref2 = &m->amb_coef[1];
+ smooth = 0.2;
+ }
+
+ if (ref1 == NULL)
+ continue; /* The instI1Monitor doesn't have a reflective cal */
+
+ vlow[0] = 1e6;
+ vhigh[0] = -1e6;
+ for (i = 0; i < m->nwav[0]; i++) {
+
+ sd[i].p[0] = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i);
+ sd[i].v[0] = ref1[i];
+ sd[i].w = 1.0;
+
+ if (sd[i].v[0] < vlow[0])
+ vlow[0] = sd[i].v[0];
+ if (sd[i].v[0] > vhigh[0])
+ vhigh[0] = sd[i].v[0];
+ }
+
+ if (ii == 1) { /* fudge factors */
+
+#ifdef NEVER /* Doesn't help */
+ /* Increase boost at short wavelegths */
+ if (m->wl_short[1] < 380.0) {
+ sd[i].p[0] = m->wl_short[1];
+ sd[i].v[0] = sd[0].v[0] * (1.0 + (380.0 - m->wl_short[1])/20.0);
+ sd[i++].w = 0.6;
+ }
+#endif
+
+#ifdef NEVER /* Doesn't help */
+ /* Reduces boost at long wavelegths */
+ if (m->wl_long[1] > 730.0) {
+ sd[i].p[0] = m->wl_long[1];
+ sd[i].v[0] = sd[m->nwav[0]-1].v[0] * (1.0 + (m->wl_long[1] - 730.0)/100.0);
+ sd[i++].w = 0.3;
+ }
+#endif
+ }
+
+ glow[0] = m->wl_short[1];
+ ghigh[0] = m->wl_long[1];
+ gres[0] = m->nwav[1];
+ avgdev[0] = 0.0;
+
+ trspl->fit_rspl_w(trspl, 0, sd, i, glow, ghigh, gres, vlow, vhigh, smooth, avgdev, NULL);
+
+ if ((*ref2 = (double *)calloc(m->nwav[1], sizeof(double))) == NULL) {
+ trspl->del(trspl);
+ a1logw(p->log, "i1pro: malloc ref2 failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ for (i = 0; i < m->nwav[1]; i++) {
+ pp.p[0] = m->wl_short[1]
+ + (double)i * (m->wl_long[1] - m->wl_short[1])/(m->nwav[1]-1.0);
+ trspl->interp(trspl, &pp);
+ (*ref2)[i] = pp.v[0];
+ }
+#ifdef HIGH_RES_PLOT
+ /* Plot original and upsampled reference */
+ {
+ double *x1 = dvectorz(0, m->nwav[1]-1);
+ double *y1 = dvectorz(0, m->nwav[1]-1);
+ double *y2 = dvectorz(0, m->nwav[1]-1);
+
+ for (i = 0; i < m->nwav[1]; i++) {
+ double wl = m->wl_short[1] + (double)i * (m->wl_long[1] - m->wl_short[1])/(m->nwav[1]-1.0);
+ x1[i] = wl;
+ y1[i] = (*ref2)[i];
+ if (wl < m->wl_short[0] || wl > m->wl_long[0]) {
+ y2[i] = 0.0;
+ } else {
+ double x, wl1, wl2;
+ for (j = 0; j < (m->nwav[0]-1); j++) {
+ wl1 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], j);
+ wl2 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], j+1);
+ if (wl >= wl1 && wl <= wl2)
+ break;
+ }
+ x = (wl - wl1)/(wl2 - wl1);
+ y2[i] = ref1[j] + (ref1[j+1] - ref1[j]) * x;
+ }
+ }
+ printf("Original and up-sampled ");
+ if (ii == 0) {
+ printf("Reflective cal. curve:\n");
+ } else if (ii == 1) {
+ ref1 = m->emis_coef[0];
+ ref2 = &m->emis_coef[1];
+ printf("Emission cal. curve:\n");
+ } else {
+ printf("Ambient cal. curve:\n");
+ }
+ do_plot(x1, y1, y2, NULL, m->nwav[1]);
+
+ free_dvector(x1, 0, m->nwav[1]-1);
+ free_dvector(y1, 0, m->nwav[1]-1);
+ free_dvector(y2, 0, m->nwav[1]-1);
+ }
+#endif /* HIGH_RES_PLOT */
+ }
+ trspl->del(trspl);
+
+ /* Upsample stray light */
+ if (p->itype == instI1Pro2) {
+#ifdef SALONEINSTLIB
+ double **slp; /* 2D Array of stray light values */
+
+ /* Then the 2D stray light using linear interpolation */
+ slp = dmatrix(0, m->nwav[0]-1, 0, m->nwav[0]-1);
+
+ /* Set scattered points */
+ for (i = 0; i < m->nwav[0]; i++) { /* Output wavelength */
+ for (j = 0; j < m->nwav[0]; j++) { /* Input wavelength */
+
+ slp[i][j] = m->straylight[0][i][j];
+
+ /* Use interpolate/extrapolate for middle points */
+ if (j == (i-1) || j == i || j == (i+1)) {
+ int j0, j1;
+ double w0, w1;
+ if (j == (i-1)) {
+ if (j <= 0)
+ j0 = j+3, j1 = j+4;
+ else if (j >= (m->nwav[0]-3))
+ j0 = j-2, j1 = j-1;
+ else
+ j0 = j-1, j1 = j+3;
+ } else if (j == i) {
+ if (j <= 1)
+ j0 = j+2, j1 = j+3;
+ else if (j >= (m->nwav[0]-2))
+ j0 = j-3, j1 = j-2;
+ else
+ j0 = j-2, j1 = j+2;
+ } else if (j == (i+1)) {
+ if (j <= 2)
+ j0 = j+1, j1 = j+2;
+ else if (j >= (m->nwav[0]-1))
+ j0 = j-4, j1 = j-3;
+ else
+ j0 = j-3, j1 = j+1;
+ }
+ w1 = (j - j0)/(j1 - j0);
+ w0 = 1.0 - w1;
+ slp[i][j] = w0 * m->straylight[0][i][j0]
+ + w1 * m->straylight[0][i][j1];
+
+ }
+ }
+ }
+#else /* !SALONEINSTLIB */
+ /* Then setup 2D stray light using rspl */
+ if ((trspl = new_rspl(RSPL_NOFLAGS, 2, 1)) == NULL) {
+ a1logd(p->log,1,"i1pro: creating rspl for high res conversion failed\n");
+ return I1PRO_INT_NEW_RSPL_FAILED;
+ }
+
+ /* Set scattered points */
+ for (i = 0; i < m->nwav[0]; i++) { /* Output wavelength */
+ for (j = 0; j < m->nwav[0]; j++) { /* Input wavelength */
+ int ix = i * m->nwav[0] + j;
+
+ sd[ix].p[0] = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], i);
+ sd[ix].p[1] = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], j);
+ sd[ix].v[0] = m->straylight[0][i][j];
+ sd[ix].w = 1.0;
+ if (j == (i-1) || j == i || j == (i+1))
+ sd[ix].w = 0.0;
+ }
+ }
+
+ glow[0] = m->wl_short[1];
+ glow[1] = m->wl_short[1];
+ ghigh[0] = m->wl_long[1];
+ ghigh[1] = m->wl_long[1];
+ gres[0] = m->nwav[1];
+ gres[1] = m->nwav[1];
+ avgdev[0] = 0.0;
+ avgdev[1] = 0.0;
+
+ trspl->fit_rspl_w(trspl, 0, sd, m->nwav[0] * m->nwav[0], glow, ghigh, gres, NULL, NULL, 0.5, avgdev, NULL);
+#endif /* !SALONEINSTLIB */
+
+ m->straylight[1] = dmatrixz(0, m->nwav[1]-1, 0, m->nwav[1]-1);
+
+ /* Create upsampled version */
+ for (i = 0; i < m->nwav[1]; i++) { /* Output wavelength */
+ for (j = 0; j < m->nwav[1]; j++) { /* Input wavelength */
+ double p0, p1;
+ p0 = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], i);
+ p1 = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], j);
+#ifdef SALONEINSTLIB
+ /* Do linear interp with clipping at ends */
+ {
+ int x0, x1, y0, y1;
+ double xx, yy, w0, w1, v0, v1;
+
+ xx = (m->nwav[0]-1.0) * (p0 - m->wl_short[0])/(m->wl_long[0] - m->wl_short[0]);
+ x0 = (int)floor(xx);
+ if (x0 <= 0)
+ x0 = 0;
+ else if (x0 >= (m->nwav[0]-2))
+ x0 = m->nwav[0]-2;
+ x1 = x0 + 1;
+ w1 = xx - (double)x0;
+ w0 = 1.0 - w1;
+
+ yy = (m->nwav[0]-1.0) * (p1 - m->wl_short[0])/(m->wl_long[0] - m->wl_short[0]);
+ y0 = (int)floor(yy);
+ if (y0 <= 0)
+ y0 = 0;
+ else if (y0 >= (m->nwav[0]-2))
+ y0 = m->nwav[0]-2;
+ y1 = y0 + 1;
+ v1 = yy - (double)y0;
+ v0 = 1.0 - v1;
+
+ pp.v[0] = w0 * v0 * slp[x0][y0]
+ + w0 * v1 * slp[x0][y1]
+ + w1 * v0 * slp[x1][y0]
+ + w1 * v1 * slp[x1][y1];
+ }
+#else /* !SALONEINSTLIB */
+ pp.p[0] = p0;
+ pp.p[1] = p1;
+ trspl->interp(trspl, &pp);
+#endif /* !SALONEINSTLIB */
+ m->straylight[1][i][j] = pp.v[0] * HIGHRES_WIDTH/10.0;
+ if (m->straylight[1][i][j] > 0.0)
+ m->straylight[1][i][j] = 0.0;
+ }
+ }
+
+ /* Fix primary wavelength weight and neighbors */
+ for (i = 0; i < m->nwav[1]; i++) { /* Output wavelength */
+ double sum;
+
+ if (i > 0)
+ m->straylight[1][i][i-1] = 0.0;
+ m->straylight[1][i][i] = 0.0;
+ if (i < (m->nwav[1]-1))
+ m->straylight[1][i][i+1] = 0.0;
+
+ for (sum = 0.0, j = 0; j < m->nwav[1]; j++)
+ sum += m->straylight[1][i][j];
+
+ m->straylight[1][i][i] = 1.0 - sum; /* Total sum should be 1.0 */
+ }
+
+#ifdef HIGH_RES_PLOT_STRAYL
+ /* Plot original and upsampled reference */
+ {
+ double *x1 = dvectorz(0, m->nwav[1]-1);
+ double *y1 = dvectorz(0, m->nwav[1]-1);
+ double *y2 = dvectorz(0, m->nwav[1]-1);
+
+ for (i = 0; i < m->nwav[1]; i++) { /* Output wavelength */
+ double wli = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], i);
+ int i1 = XSPECT_IX(m->wl_short[0], m->wl_long[0], m->nwav[0], wli);
+
+ for (j = 0; j < m->nwav[1]; j++) {
+ double wl = XSPECT_WL(m->wl_short[1], m->wl_long[1], m->nwav[1], j);
+ x1[j] = wl;
+ y1[j] = m->straylight[1][i][j];
+ if (y1[j] == 0.0)
+ y1[j] = -8.0;
+ else
+ y1[j] = log10(fabs(y1[j]));
+ if (wli < m->wl_short[0] || wli > m->wl_long[0]
+ || wl < m->wl_short[0] || wl > m->wl_long[0]) {
+ y2[j] = -8.0;
+ } else {
+ double x, wl1, wl2;
+ for (k = 0; k < (m->nwav[0]-1); k++) {
+ wl1 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], k);
+ wl2 = XSPECT_WL(m->wl_short[0], m->wl_long[0], m->nwav[0], k+1);
+ if (wl >= wl1 && wl <= wl2)
+ break;
+ }
+ x = (wl - wl1)/(wl2 - wl1);
+ y2[j] = m->straylight[0][i1][k] + (m->straylight[0][i1][k+1]
+ - m->straylight[0][i1][k]) * x;
+ if (y2[j] == 0.0)
+ y2[j] = -8.0;
+ else
+ y2[j] = log10(fabs(y2[j]));
+ }
+ }
+ do_plot(x1, y1, y2, NULL, m->nwav[1]);
+ }
+
+ free_dvector(x1, 0, m->nwav[1]-1);
+ free_dvector(y1, 0, m->nwav[1]-1);
+ free_dvector(y2, 0, m->nwav[1]-1);
+ }
+#endif /* HIGH_RES_PLOT */
+
+#ifdef SALONEINSTLIB
+ free_dmatrix(slp, 0, m->nwav[0]-1, 0, m->nwav[0]-1);
+#else /* !SALONEINSTLIB */
+ trspl->del(trspl);
+#endif /* !SALONEINSTLIB */
+ }
+ }
+
+ /* Create or re-create the high resolution filters */
+ for (refl = 0; refl < 2; refl++) { /* for emis/trans and reflective */
+ double fshmax; /* filter shape max wavelength from center */
+#define MXNOFC 64
+ i1pro_fc coeff2[500][MXNOFC]; /* New filter cooefficients */
+ double twidth;
+
+ /* Construct a set of filters that uses more CCD values */
+ twidth = HIGHRES_WIDTH;
+
+ if (m->nwav[1] > 500) { /* Assert */
+ a1loge(p->log,1,"High res filter has too many bands\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ /* Use a simple means of determining width */
+ for (fshmax = 50.0; fshmax >= 0.0; fshmax -= 0.1) {
+ if (fabs(lanczos2(twidth, fshmax)) > 0.0001) {
+ fshmax += 0.1;
+ break;
+ }
+ }
+ if (fshmax <= 0.0) {
+ a1logw(p->log, "i1pro: fshmax search failed\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+// printf("~1 fshmax = %f\n",fshmax);
+
+#ifdef HIGH_RES_DEBUG
+ /* Check that the filter sums to a constant */
+ {
+ double x, sum;
+
+ for (x = 0.0; x < 5.0; x += 0.1) {
+ sum = 0;
+ sum += lin_fshape(fshape, ncp, x - 15.0);
+ sum += lin_fshape(fshape, ncp, x - 10.0);
+ sum += lin_fshape(fshape, ncp, x - 5.0);
+ sum += lin_fshape(fshape, ncp, x - 0.0);
+ sum += lin_fshape(fshape, ncp, x + 5.0);
+ sum += lin_fshape(fshape, ncp, x + 10.0);
+ printf("Offset %f, sum %f\n",x, sum);
+ }
+ }
+#endif /* HIGH_RES_DEBUG */
+
+ /* Create all the filters */
+ if (m->mtx_c[1][refl].nocoef != NULL)
+ free(m->mtx_c[1][refl].nocoef);
+ if ((m->mtx_c[1][refl].nocoef = (int *)calloc(m->nwav[1], sizeof(int))) == NULL) {
+ a1logw(p->log, "i1pro: malloc nocoef failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ /* For all the useful CCD bands */
+ for (i = 1; i < 127; i++) {
+ double w1, wl, w2;
+
+ /* Translate CCD center and boundaries to calibrated wavelength */
+ wl = i1pro_raw2wav(p, refl, (double)i);
+ w1 = i1pro_raw2wav(p, refl, (double)i - 0.5);
+ w2 = i1pro_raw2wav(p, refl, (double)i + 0.5);
+
+// printf("~1 CCD %d, w1 %f, wl %f, w2 %f\n",i,w1,wl,w2);
+
+ /* For each filter */
+ for (j = 0; j < m->nwav[1]; j++) {
+ double cwl, rwl; /* center, relative wavelegth */
+ double we;
+
+ cwl = m->wl_short[1] + (double)j * (m->wl_long[1] - m->wl_short[1])/(m->nwav[1]-1.0);
+ rwl = wl - cwl; /* relative wavelength to filter */
+
+ if (fabs(w1 - cwl) > fshmax && fabs(w2 - cwl) > fshmax)
+ continue; /* Doesn't fall into this filter */
+
+ /* Integrate in 0.05 nm increments from filter shape */
+ /* using triangular integration. */
+ {
+ int nn;
+ double lw, ll;
+
+ nn = (int)(fabs(w2 - w1)/0.05 + 0.5); /* Number to integrate over */
+
+ lw = w1; /* start at lower boundary of CCD cell */
+ ll = lanczos2(twidth, w1- cwl);
+ we = 0.0;
+ for (k = 0; k < nn; k++) {
+ double cw, cl;
+
+#if defined(__APPLE__) && defined(__POWERPC__)
+ gcc_bug_fix(k);
+#endif
+ cw = w1 + (k+1.0)/(nn +1.0) * (w2 - w1); /* wl to sample */
+ cl = lanczos2(twidth, cw- cwl);
+ we += 0.5 * (cl + ll) * (lw - cw); /* Area under triangle */
+ ll = cl;
+ lw = cw;
+ }
+ }
+
+ if (m->mtx_c[1][refl].nocoef[j] >= MXNOFC) {
+ a1logw(p->log, "i1pro: run out of high res filter space\n");
+ return I1PRO_INT_ASSERT;
+ }
+
+ coeff2[j][m->mtx_c[1][refl].nocoef[j]].ix = i;
+ coeff2[j][m->mtx_c[1][refl].nocoef[j]++].we = we;
+// printf("~1 filter %d, cwl %f, rwl %f, ix %d, we %f, nocoefs %d\n",j,cwl,rwl,i,we,m->mtx_c[1][refl].nocoef[j]-1);
+ }
+ }
+
+#ifdef HIGH_RES_PLOT
+ /* Plot resampled curves */
+ {
+ double *xx, *ss;
+ double **yy;
+
+ xx = dvectorz(-1, m->nraw-1); /* X index */
+ yy = dmatrixz(0, 5, -1, m->nraw-1); /* Curves distributed amongst 5 graphs */
+
+ for (i = 0; i < m->nraw; i++)
+ xx[i] = i;
+
+ /* For each output wavelength */
+ for (j = 0; j < m->nwav[1]; j++) {
+ i = j % 5;
+
+ /* For each matrix value */
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++) {
+ yy[5][coeff2[j][k].ix] += 0.5 * coeff2[j][k].we;
+ yy[i][coeff2[j][k].ix] = coeff2[j][k].we;
+ }
+ }
+
+ printf("Hi-Res wavelength sampling curves:\n");
+ do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+ free_dvector(xx, -1, m->nraw-1);
+ free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+ }
+#endif /* HIGH_RES_PLOT */
+
+ /* Normalise the filters area in CCD space, while maintaining the */
+ /* total contribution of each CCD at the target too. */
+ {
+ int ii;
+ double tot = 0.0;
+ double ccdweight[128], avgw; /* Weighting determined by cell widths */
+ double ccdsum[128];
+
+ /* Normalize the overall filter weightings */
+ for (j = 0; j < m->nwav[1]; j++)
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+ tot += coeff2[j][k].we;
+ tot /= (double)m->nwav[1];
+ for (j = 0; j < m->nwav[1]; j++)
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+ coeff2[j][k].we /= tot;
+
+ /* Determine the relative weights for each CCD */
+ avgw = 0.0;
+ for (i = 1; i < 127; i++) {
+
+ ccdweight[i] = i1pro_raw2wav(p, refl, (double)i - 0.5)
+ - i1pro_raw2wav(p, refl, (double)i + 0.5);
+ ccdweight[i] = fabs(ccdweight[i]);
+ avgw += ccdweight[i];
+ }
+ avgw /= 126.0;
+ // ~~this isn't right because not all CCD's get used!!
+
+#ifdef NEVER
+ /* Itterate */
+ for (ii = 0; ; ii++) {
+
+ /* Normalize the individual filter weightings */
+ for (j = 0; j < m->nwav[1]; j++) {
+ double err;
+ tot = 0.0;
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+ tot += coeff2[j][k].we;
+ err = 1.0 - tot;
+
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+ coeff2[j][k].we += err/m->mtx_c[1][refl].nocoef[j];
+// for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+// coeff2[j][k].we *= 1.0/tot;
+ }
+
+ /* Check CCD sums */
+ for (i = 1; i < 127; i++)
+ ccdsum[i] = 0.0;
+
+ for (j = 0; j < m->nwav[1]; j++) {
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+ ccdsum[coeff2[j][k].ix] += coeff2[j][k].we;
+ }
+
+ if (ii >= 6)
+ break;
+
+ /* Readjust CCD sum */
+ for (i = 1; i < 127; i++) {
+ ccdsum[i] = ccdtsum[i]/ccdsum[i]; /* Amount to adjust */
+ }
+
+ for (j = 0; j < m->nwav[1]; j++) {
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++)
+ coeff2[j][k].we *= ccdsum[coeff2[j][k].ix];
+ }
+ }
+#endif /* NEVER */
+ }
+
+#ifdef HIGH_RES_PLOT
+ /* Plot resampled curves */
+ {
+ double *xx, *ss;
+ double **yy;
+
+ xx = dvectorz(-1, m->nraw-1); /* X index */
+ yy = dmatrixz(0, 5, -1, m->nraw-1); /* Curves distributed amongst 5 graphs */
+
+ for (i = 0; i < m->nraw; i++)
+ xx[i] = i;
+
+ /* For each output wavelength */
+ for (j = 0; j < m->nwav[1]; j++) {
+ i = j % 5;
+
+ /* For each matrix value */
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++) {
+ yy[5][coeff2[j][k].ix] += 0.5 * coeff2[j][k].we;
+ yy[i][coeff2[j][k].ix] = coeff2[j][k].we;
+ }
+ }
+
+ printf("Normalized Hi-Res wavelength sampling curves:\n");
+ do_plot6(xx, yy[0], yy[1], yy[2], yy[3], yy[4], yy[5], m->nraw);
+ free_dvector(xx, -1, m->nraw-1);
+ free_dmatrix(yy, 0, 2, -1, m->nraw-1);
+ }
+#endif /* HIGH_RES_PLOT */
+
+ /* Convert hires filters into runtime format */
+ {
+ int xcount;
+
+ /* Allocate or reallocate high res filter tables */
+ if (m->mtx_c[1][refl].index != NULL)
+ free(m->mtx_c[1][refl].index);
+ if (m->mtx_c[1][refl].coef != NULL)
+ free(m->mtx_c[1][refl].coef);
+
+ if ((m->mtx_c[1][refl].index = (int *)calloc(m->nwav[1], sizeof(int))) == NULL) {
+ a1logw(p->log, "i1pro: malloc index failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ xcount = 0;
+ for (j = 0; j < m->nwav[1]; j++) {
+ m->mtx_c[1][refl].index[j] = coeff2[j][0].ix;
+ xcount += m->mtx_c[1][refl].nocoef[j];
+ }
+
+ if ((m->mtx_c[1][refl].coef = (double *)calloc(xcount, sizeof(double))) == NULL) {
+ a1logw(p->log, "i1pro: malloc coef failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ for (i = j = 0; j < m->nwav[1]; j++)
+ for (k = 0; k < m->mtx_c[1][refl].nocoef[j]; k++, i++)
+ m->mtx_c[1][refl].coef[i] = coeff2[j][k].we;
+
+ /* Set high res tables to new allocations */
+ m->mtx[1][refl] = m->mtx_c[1][refl];
+ }
+ }
+
+ /* Generate high res. per mode calibration factors. */
+ if (!m->hr_inited) {
+
+ m->hr_inited = 1; /* Set so that i1pro_compute_white_cal() etc. does right thing */
+
+ for (i = 0; i < i1p_no_modes; i++) {
+ i1pro_state *s = &m->ms[i];
+
+ if (s->cal_factor[1] == NULL)
+ s->cal_factor[1] = dvectorz(0, m->nwav[1]-1);
+
+ switch(i) {
+ case i1p_refl_spot:
+ case i1p_refl_scan:
+ if (s->cal_valid) {
+ /* (Using cal_factor[] as temp. for i1pro_absraw_to_abswav()) */
+#ifdef NEVER
+ printf("~1 regenerating calibration for reflection\n");
+ printf("~1 raw white data:\n");
+ plot_raw(s->white_data);
+#endif /* NEVER */
+ i1pro_absraw_to_abswav(p, 0, s->reflective, 1, &s->cal_factor[0], &s->white_data);
+#ifdef NEVER
+ printf("~1 Std res intmd. cal_factor:\n");
+ plot_wav(m, 0, s->cal_factor[0]);
+#endif /* NEVER */
+ i1pro_absraw_to_abswav(p, 1, s->reflective, 1, &s->cal_factor[1], &s->white_data);
+#ifdef NEVER
+ printf("~1 High intmd. cal_factor:\n");
+ plot_wav(m, 1, s->cal_factor[1]);
+ printf("~1 Std res white ref:\n");
+ plot_wav(m, 0, m->white_ref[0]);
+ printf("~1 High res white ref:\n");
+ plot_wav(m, 1, m->white_ref[1]);
+#endif /* NEVER */
+ i1pro_compute_white_cal(p, s->cal_factor[0], m->white_ref[0], s->cal_factor[0],
+ s->cal_factor[1], m->white_ref[1], s->cal_factor[1]);
+#ifdef NEVER
+ printf("~1 Std res final cal_factor:\n");
+ plot_wav(m, 0, s->cal_factor[0]);
+ printf("~1 High final cal_factor:\n");
+ plot_wav(m, 1, s->cal_factor[1]);
+#endif /* NEVER */
+ }
+ break;
+
+ case i1p_emiss_spot_na:
+ case i1p_emiss_spot:
+ case i1p_emiss_scan:
+ for (j = 0; j < m->nwav[1]; j++)
+ s->cal_factor[1][j] = EMIS_SCALE_FACTOR * m->emis_coef[1][j];
+ break;
+
+ case i1p_amb_spot:
+ case i1p_amb_flash:
+#ifdef FAKE_AMBIENT
+ for (j = 0; j < m->nwav[1]; j++)
+ s->cal_factor[1][j] = EMIS_SCALE_FACTOR * m->emis_coef[1][j];
+ s->cal_valid = 1;
+#else
+
+ if (m->amb_coef[0] != NULL) {
+ for (j = 0; j < m->nwav[1]; j++)
+ s->cal_factor[1][j] = AMB_SCALE_FACTOR * m->emis_coef[1][j] * m->amb_coef[1][j];
+ s->cal_valid = 1;
+ }
+#endif
+ break;
+ case i1p_trans_spot:
+ case i1p_trans_scan:
+ if (s->cal_valid) {
+ /* (Using cal_factor[] as temp. for i1pro_absraw_to_abswav()) */
+ i1pro_absraw_to_abswav(p, 0, s->reflective, 1, &s->cal_factor[0], &s->white_data);
+ i1pro_absraw_to_abswav(p, 1, s->reflective, 1, &s->cal_factor[1], &s->white_data);
+ i1pro_compute_white_cal(p, s->cal_factor[0], NULL, s->cal_factor[0],
+ s->cal_factor[1], NULL, s->cal_factor[1]);
+ }
+ break;
+ }
+ }
+ }
+
+ /* Hires has been initialised */
+ m->hr_inited = 1;
+
+ return ev;
+}
+
+#endif /* HIGH_RES */
+
+
+/* return nz if high res is supported */
+int i1pro_imp_highres(i1pro *p) {
+#ifdef HIGH_RES
+ return 1;
+#else
+ return 0;
+#endif /* HIGH_RES */
+}
+
+/* Set to high resolution mode */
+i1pro_code i1pro_set_highres(i1pro *p) {
+ int i;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+
+#ifdef HIGH_RES
+ if (m->hr_inited == 0) {
+ if ((ev = i1pro_create_hr(p)) != I1PRO_OK)
+ return ev;
+ }
+ m->highres = 1;
+#else
+ ev = I1PRO_UNSUPPORTED;
+#endif /* HIGH_RES */
+
+ return ev;
+}
+
+/* Set to standard resolution mode */
+i1pro_code i1pro_set_stdres(i1pro *p) {
+ int i;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+
+#ifdef HIGH_RES
+ m->highres = 0;
+#else
+ ev = I1PRO_UNSUPPORTED;
+#endif /* HIGH_RES */
+
+ return ev;
+}
+
+/* =============================================== */
+
+/* Modify the scan consistency tolerance */
+i1pro_code i1pro_set_scan_toll(i1pro *p, double toll_ratio) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code ev = I1PRO_OK;
+
+ m->scan_toll_ratio = toll_ratio;
+
+ return I1PRO_OK;
+}
+
+
+/* Optics adjustment weights */
+static double opt_adj_weights[21] = {
+ 1.4944496665144658e-282, 2.0036175483913455e-070, 1.2554893022685038e+232,
+ 2.3898157055642966e+190, 1.5697625128432372e-076, 6.6912978722191457e+281,
+ 1.2369092402930559e+277, 1.4430907501246712e-153, 3.0017439193018232e+238,
+ 1.2978311824382444e+161, 5.5068703318775818e-311, 7.7791723264455314e-260,
+ 6.4560484084110176e+170, 8.9481529920968425e+165, 1.3565405878488529e-153,
+ 2.0835868791190880e-076, 5.4310198502711138e+241, 4.8689849775675438e+275,
+ 9.2709981544886391e+122, 3.7958270103353899e-153, 7.1366083837501666e-154
+};
+
+/* Convert from spectral to XYZ, and transfer to the ipatch array */
+i1pro_code i1pro_conv2XYZ(
+ i1pro *p,
+ ipatch *vals, /* Values to return */
+ int nvals, /* Number of values */
+ double **specrd, /* Spectral readings */
+ instClamping clamp /* Clamp XYZ/Lab to be +ve */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ xsp2cie *conv; /* Spectral to XYZ conversion object */
+ int i, j, k;
+ int six = 0; /* Starting index */
+ int nwl = m->nwav[m->highres]; /* Number of wavelegths */
+ double wl_short = m->wl_short[m->highres]; /* Starting wavelegth */
+ double sms; /* Weighting */
+
+ if (s->emiss)
+ conv = new_xsp2cie(icxIT_none, NULL, icxOT_CIE_1931_2, NULL, icSigXYZData, (icxClamping)clamp);
+ else
+ conv = new_xsp2cie(icxIT_D50, NULL, icxOT_CIE_1931_2, NULL, icSigXYZData, (icxClamping)clamp);
+ if (conv == NULL)
+ return I1PRO_INT_CIECONVFAIL;
+
+ /* Don't report any wavelengths below the minimum for this mode */
+ if ((s->min_wl-1e-3) > wl_short) {
+ double wl = 0.0;
+ for (j = 0; j < m->nwav[m->highres]; j++) {
+ wl = XSPECT_WL(m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], j);
+ if (wl >= (s->min_wl-1e-3))
+ break;
+ }
+ six = j;
+ wl_short = wl;
+ nwl -= six;
+ }
+
+ a1logd(p->log,5,"i1pro_conv2XYZ got wl_short %f, wl_long %f, nwav %d, min_wl %f\n",
+ m->wl_short[m->highres], m->wl_long[m->highres], m->nwav[m->highres], s->min_wl);
+ a1logd(p->log,5," after skip got wl_short %f, nwl = %d\n", wl_short, nwl);
+
+ for (sms = 0.0, i = 1; i < 21; i++)
+ sms += opt_adj_weights[i];
+ sms *= opt_adj_weights[0];
+
+ for (i = 0; i < nvals; i++) {
+
+ vals[i].loc[0] = '\000';
+ vals[i].mtype = inst_mrt_none;
+ vals[i].XYZ_v = 0;
+ vals[i].sp.spec_n = 0;
+ vals[i].duration = 0.0;
+
+ vals[i].sp.spec_n = nwl;
+ vals[i].sp.spec_wl_short = wl_short;
+ vals[i].sp.spec_wl_long = m->wl_long[m->highres];
+
+ if (s->emiss) {
+ /* Leave spectral values as mW/m^2 */
+ for (j = six, k = 0; j < m->nwav[m->highres]; j++, k++) {
+ vals[i].sp.spec[k] = specrd[i][j] * sms;
+ }
+ vals[i].sp.norm = 1.0;
+
+ /* Set the XYZ */
+ conv->convert(conv, vals[i].XYZ, &vals[i].sp);
+ vals[i].XYZ_v = 1;
+
+ if (s->ambient) {
+ if (s->flash)
+ vals[i].mtype = inst_mrt_ambient_flash;
+ else
+ vals[i].mtype = inst_mrt_ambient;
+ } else {
+ if (s->flash)
+ vals[i].mtype = inst_mrt_emission_flash;
+ else
+ vals[i].mtype = inst_mrt_emission;
+ }
+
+ } else {
+ /* Scale spectral values to percentage reflectance */
+ for (j = six, k = 0; j < m->nwav[m->highres]; j++, k++) {
+ vals[i].sp.spec[k] = 100.0 * specrd[i][j] * sms;
+ }
+ vals[i].sp.norm = 100.0;
+
+ /* Set the XYZ */
+ conv->convert(conv, vals[i].XYZ, &vals[i].sp);
+ vals[i].XYZ_v = 1;
+ vals[i].XYZ[0] *= 100.0;
+ vals[i].XYZ[1] *= 100.0;
+ vals[i].XYZ[2] *= 100.0;
+
+ if (s->trans)
+ vals[i].mtype = inst_mrt_transmissive;
+ else
+ vals[i].mtype = inst_mrt_reflective;
+ }
+
+ /* Don't return spectral if not asked for */
+ if (!m->spec_en) {
+ vals[i].sp.spec_n = 0;
+ }
+ }
+
+ conv->del(conv);
+ return I1PRO_OK;
+}
+
+/* Check a reflective white reference measurement to see if */
+/* it seems reasonable. Return I1PRO_OK if it is, error if not. */
+i1pro_code i1pro_check_white_reference1(
+ i1pro *p,
+ double *abswav /* [nwav[0]] Measurement to check */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ double *emiswav, normfac;
+ double avg01, avg2227;
+ int j;
+
+ emiswav = dvector(-1, m->nraw-1);
+
+ /* Convert from absolute wavelength converted sensor reading, */
+ /* to calibrated emission wavelength spectrum. */
+
+ /* For each output wavelength */
+ for (j = 0; j < m->nwav[0]; j++) {
+ emiswav[j] = m->emis_coef[0][j] * abswav[j];
+ }
+#ifdef PLOT_DEBUG
+ printf("White ref read converted to emissive spectrum:\n");
+ plot_wav(m, 0, emiswav);
+#endif
+
+ /* Normalise the measurement to the reflectance of the 17 wavelength */
+ /* of the white reference (550nm), as well as dividing out the */
+ /* reference white. This should leave us with the iluminant spectrum, */
+ normfac = m->white_ref[0][17]/emiswav[17];
+
+ for (j = 0; j < m->nwav[0]; j++) {
+ emiswav[j] *= normfac/m->white_ref[0][j];
+ }
+
+#ifdef PLOT_DEBUG
+ printf("normalised to reference white read:\n");
+ plot_wav(m, 0, emiswav);
+#endif
+
+ /* Compute two sample averages of the illuminant spectrum. */
+ avg01 = 0.5 * (emiswav[0] + emiswav[1]);
+
+ for (avg2227 = 0, j = 22; j < 28; j++) {
+ avg2227 += emiswav[j];
+ }
+ avg2227 /= (double)(28 - 22);
+
+ free_dvector(emiswav, -1, m->nraw-1);
+
+ /* And check them against tolerance for the illuminant. */
+ if (m->physfilt == 0x82) { /* UV filter */
+ if (0.0 < avg01 && avg01 < 0.05
+ && 1.2 < avg2227 && avg2227 < 1.76) {
+ return I1PRO_OK;
+ }
+
+ } else { /* No filter */
+ if (0.11 < avg01 && avg01 < 0.22
+ && 1.35 < avg2227 && avg2227 < 1.6) {
+ return I1PRO_OK;
+ }
+ }
+ a1logd(p->log,2,"Checking white reference failed, 0.11 < avg01 %f < 0.22, 1.35 < avg2227 %f < 1.6\n",avg01,avg2227);
+ return I1PRO_RD_WHITEREFERROR;
+}
+
+/* Compute a mode calibration factor given the reading of the white reference. */
+/* Return 1 if any of the transmission wavelengths are low. */
+int i1pro_compute_white_cal(
+ i1pro *p,
+ double *cal_factor0, /* [nwav[0]] Calibration factor to compute */
+ double *white_ref0, /* [nwav[0]] White reference to aim for, NULL for 1.0 */
+ double *white_read0, /* [nwav[0]] The white that was read */
+ double *cal_factor1, /* [nwav[1]] Calibration factor to compute */
+ double *white_ref1, /* [nwav[1]] White reference to aim for, NULL for 1.0 */
+ double *white_read1 /* [nwav[1]] The white that was read */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ int j, warn = 0;;
+
+ if (white_ref0 == NULL) { /* transmission white reference */
+ double avgwh = 0.0;
+
+ /* Compute average white reference reading */
+ for (j = 0; j < m->nwav[0]; j++)
+ avgwh += white_read0[j];
+ avgwh /= (double)m->nwav[0];
+
+ /* For each wavelength */
+ for (j = 0; j < m->nwav[0]; j++) {
+ /* If reference is < 0.4% of average */
+ if (white_read0[j]/avgwh < 0.004) {
+ cal_factor0[j] = 1.0/(0.004 * avgwh);
+ warn = 1;
+ } else {
+ cal_factor0[j] = 1.0/white_read0[j];
+ }
+ }
+
+ } else { /* Reflection white reference */
+
+ /* For each wavelength */
+ for (j = 0; j < m->nwav[0]; j++) {
+ if (white_read0[j] < 1000.0)
+ cal_factor0[j] = white_ref0[j]/1000.0;
+ else
+ cal_factor0[j] = white_ref0[j]/white_read0[j];
+ }
+ }
+
+#ifdef HIGH_RES
+ if (m->hr_inited == 0)
+ return warn;
+
+ if (white_ref1 == NULL) { /* transmission white reference */
+ double avgwh = 0.0;
+
+ /* Compute average white reference reading */
+ for (j = 0; j < m->nwav[1]; j++)
+ avgwh += white_read1[j];
+ avgwh /= (double)m->nwav[1];
+
+ /* For each wavelength */
+ for (j = 0; j < m->nwav[1]; j++) {
+ /* If reference is < 0.4% of average */
+ if (white_read1[j]/avgwh < 0.004) {
+ cal_factor1[j] = 1.0/(0.004 * avgwh);
+ warn = 1;
+ } else {
+ cal_factor1[j] = 1.0/white_read1[j];
+ }
+ }
+
+ } else { /* Reflection white reference */
+
+ /* For each wavelength */
+ for (j = 0; j < m->nwav[1]; j++) {
+ if (white_read1[j] < 1000.0)
+ cal_factor1[j] = white_ref1[j]/1000.0;
+ else
+ cal_factor1[j] = white_ref1[j]/white_read1[j];
+ }
+ }
+#endif /* HIGH_RES */
+ return warn;
+}
+
+/* For adaptive mode, compute a new integration time and gain mode */
+/* in order to optimise the sensor values. Note that the Rev E doesn't have */
+/* a high gain mode. */
+i1pro_code i1pro_optimise_sensor(
+ i1pro *p,
+ double *pnew_int_time,
+ int *pnew_gain_mode,
+ double cur_int_time,
+ int cur_gain_mode,
+ int permithg, /* nz to permit switching to high gain mode */
+ int permitclip, /* nz to permit clipping out of range int_time, else error */
+ double targoscale, /* Optimising target scale ( <= 1.0) */
+ double scale /* scale needed of current int time to reach optimum */
+) {
+ i1pro_code ev = I1PRO_OK;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ double new_int_time;
+ int new_gain_mode;
+
+ a1logd(p->log,3,"i1pro_optimise_sensor called, inttime %f, gain mode %d, targ scale %f, scale %f\n",cur_int_time,cur_gain_mode, targoscale, scale);
+
+ /* Compute new normal gain integration time */
+ if (cur_gain_mode) /* If high gain */
+ new_int_time = cur_int_time * scale * m->highgain;
+ else
+ new_int_time = cur_int_time * scale;
+ new_gain_mode = 0;
+
+ a1logd(p->log,3,"target inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+ /* Adjust to low light situation by increasing the integration time. */
+ if (new_int_time > s->targmaxitime) { /* Exceeding target integration time */
+ if (s->targmaxitime/new_int_time > s->targoscale2) { /* But within range */
+ /* Compromise sensor target value to maintain targmaxitime */
+ new_int_time = s->targmaxitime;
+ a1logd(p->log,3,"Using targmaxitime with compromise sensor target\n");
+ } else {
+ /* Target reduced sensor value to give improved measurement time and continuity */
+ new_int_time *= s->targoscale2;
+ a1logd(p->log,3,"Using compromse sensor target\n");
+ }
+#ifdef USE_HIGH_GAIN_MODE
+ /* !! Should change this so that it doesn't affect int. time, */
+ /* but that we simply switch to high gain mode when the */
+ /* expected level is < target_level/gain */
+ /* Hmm. It may not be a good idea to use high gain mode if it compromises */
+ /* the longer integration time which reduces noise. */
+ if (p->itype != instI1Pro2 && new_int_time > m->max_int_time && permithg) {
+ new_int_time /= m->highgain;
+ new_gain_mode = 1;
+ a1logd(p->log,3,"Switching to high gain mode\n");
+ }
+#endif
+ }
+ a1logd(p->log,3,"after low light adjust, inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+ /* Deal with still low light */
+ if (new_int_time > m->max_int_time) {
+ if (permitclip)
+ new_int_time = m->max_int_time;
+ else
+ return I1PRO_RD_LIGHTTOOLOW;
+ }
+ a1logd(p->log,3,"after low light clip, inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+ /* Adjust to high light situation */
+ if (new_int_time < m->min_int_time && targoscale < 1.0) {
+ new_int_time /= targoscale; /* Aim for non-scaled sensor optimum */
+ if (new_int_time > m->min_int_time) /* But scale as much as possible */
+ new_int_time = m->min_int_time;
+ }
+ a1logd(p->log,3,"after high light adjust, inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+ /* Deal with still high light */
+ if (new_int_time < m->min_int_time) {
+ if (permitclip)
+ new_int_time = m->min_int_time;
+ else
+ return I1PRO_RD_LIGHTTOOHIGH;
+ }
+ a1logd(p->log,3,"after high light clip, returning inttime %f, gain mode %d\n",new_int_time,new_gain_mode);
+
+ if (pnew_int_time != NULL)
+ *pnew_int_time = new_int_time;
+
+ if (pnew_gain_mode != NULL)
+ *pnew_gain_mode = new_gain_mode;
+
+ return I1PRO_OK;
+}
+
+/* Compute the number of measurements needed, given the target */
+/* measurement time and integration time. Will return 0 if target time is 0 */
+int i1pro_comp_nummeas(
+ i1pro *p,
+ double meas_time,
+ double int_time
+) {
+ int nmeas;
+ if (meas_time <= 0.0)
+ return 0;
+ nmeas = (int)floor(meas_time/int_time + 0.5);
+ if (nmeas < 1)
+ nmeas = 1;
+ return nmeas;
+}
+
+/* Convert the dark interpolation data to a useful state */
+/* (also allow for interpolating the shielded cell values) */
+void
+i1pro_prepare_idark(
+ i1pro *p
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ int i, j;
+
+ /* For normal and high gain */
+ for (i = 0; i < 4; i+= 2) {
+ for (j = -1; j < m->nraw; j++) {
+ double d01, d1;
+ d01 = s->idark_data[i+0][j] * s->idark_int_time[i+0];
+ d1 = s->idark_data[i+1][j] * s->idark_int_time[i+1];
+
+ /* Compute increment */
+ s->idark_data[i+1][j] = (d1 - d01)/(s->idark_int_time[i+1] - s->idark_int_time[i+0]);
+
+ /* Compute base */
+ s->idark_data[i+0][j] = d01 - s->idark_data[i+1][j] * s->idark_int_time[i+0];
+ }
+ if (p->itype == instI1Pro2) /* Rev E doesn't have high gain mode */
+ break;
+ }
+}
+
+/* Create the dark reference for the given integration time and gain */
+/* by interpolating from the 4 readings taken earlier. */
+i1pro_code
+i1pro_interp_dark(
+ i1pro *p,
+ double *result, /* Put result of interpolation here */
+ double inttime,
+ int gainmode
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_state *s = &m->ms[m->mmode];
+ int i, j;
+
+ if (!s->idark_valid)
+ return I1PRO_INT_NOTCALIBRATED;
+
+ i = 0;
+#ifdef USE_HIGH_GAIN_MODE
+ if (gainmode)
+ i = 2;
+#endif
+
+ for (j = -1; j < m->nraw; j++) {
+ double tt;
+ tt = s->idark_data[i+0][j] + inttime * s->idark_data[i+1][j];
+ tt /= inttime;
+ result[j] = tt;
+ }
+ return I1PRO_OK;
+}
+
+/* Set the noinitcalib mode */
+void i1pro_set_noinitcalib(i1pro *p, int v, int losecs) {
+ i1proimp *m = (i1proimp *)p->m;
+
+ /* Ignore disabling init calib if more than losecs since instrument was open */
+ if (v && losecs != 0 && m->lo_secs >= losecs) {
+ a1logd(p->log,3,"initcalib disable ignored because %d >= %d secs\n",m->lo_secs,losecs);
+ return;
+ }
+ m->noinitcalib = v;
+}
+
+/* Set the trigger config */
+void i1pro_set_trig(i1pro *p, inst_opt_type trig) {
+ i1proimp *m = (i1proimp *)p->m;
+ m->trig = trig;
+}
+
+/* Return the trigger config */
+inst_opt_type i1pro_get_trig(i1pro *p) {
+ i1proimp *m = (i1proimp *)p->m;
+ return m->trig;
+}
+
+/* Switch thread handler */
+int i1pro_switch_thread(void *pp) {
+ int nfailed = 0;
+ i1pro *p = (i1pro *)pp;
+ i1proimp *m = (i1proimp *)p->m;
+ i1pro_code rv = I1PRO_OK;
+ a1logd(p->log,3,"Switch thread started\n");
+ for (nfailed = 0;nfailed < 5;) {
+ rv = i1pro_waitfor_switch_th(p, SW_THREAD_TIMEOUT);
+ a1logd(p->log,8,"Switch handler triggered with rv %d, th_term %d\n",rv,m->th_term);
+ if (m->th_term) {
+ m->th_termed = 1;
+ break;
+ }
+ if (rv == I1PRO_INT_BUTTONTIMEOUT) {
+ nfailed = 0;
+ continue;
+ }
+ if (rv != I1PRO_OK) {
+ nfailed++;
+ a1logd(p->log,3,"Switch thread failed with 0x%x\n",rv);
+ continue;
+ }
+ m->switch_count++;
+ if (!m->hide_switch && p->eventcallback != NULL) {
+ p->eventcallback(p->event_cntx, inst_event_switch);
+ }
+ }
+ a1logd(p->log,3,"Switch thread returning\n");
+ return rv;
+}
+
+/* ============================================================ */
+/* Low level i1pro commands */
+
+/* USB Instrument commands */
+
+/* Reset the instrument */
+i1pro_code
+i1pro_reset(
+ i1pro *p,
+ int mask /* reset mask ?. Known values ar 0x1f, 0x07, 0x01 */
+ /* 0x1f = normal resent */
+ /* 0x01 = establish high power mode */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[2]; /* 1 or 2 bytes to write */
+ int len = 1; /* Message length */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_reset: reset with mask 0x%02x @ %d msec\n",
+ mask,(stime = msec_time()) - m->msec);
+
+ pbuf[0] = mask;
+
+ if (p->itype == instI1Pro2) {
+ pbuf[1] = 0; /* Not known what i1pro2 second byte is for */
+ len = 2;
+ }
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xCA, 0, 0, pbuf, len, 2.0);
+
+ rv = icoms2i1pro_err(se);
+
+ a1logd(p->log,2,"i1pro_reset: complete, ICOM err 0x%x (%d msec)\n",se,msec_time()-stime);
+
+ /* Allow time for hardware to stabalize */
+ msec_sleep(100);
+
+ /* Make sure that we re-initialize the measurement mode */
+ m->c_intclocks = 0;
+ m->c_lampclocks = 0;
+ m->c_nummeas = 0;
+ m->c_measmodeflags = 0;
+
+ return rv;
+}
+
+/* Read from the EEProm */
+i1pro_code
+i1pro_readEEProm(
+ i1pro *p,
+ unsigned char *buf, /* Where to read it to */
+ int addr, /* Address in EEprom to read from */
+ int size /* Number of bytes to read (max 65535) */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int rwbytes; /* Data bytes read or written */
+ unsigned char pbuf[8]; /* Write EEprom parameters */
+ int len = 8; /* Message length */
+ int se, rv = I1PRO_OK;
+ int stime;
+
+ if (size >= 0x10000)
+ return I1PRO_INT_EETOOBIG;
+
+ a1logd(p->log,2,"i1pro_readEEProm: address 0x%x size 0x%x @ %d msec\n",
+ addr, size, (stime = msec_time()) - m->msec);
+
+ int2buf(&pbuf[0], addr);
+ short2buf(&pbuf[4], size);
+ pbuf[6] = pbuf[7] = 0; /* Ignored */
+
+ if (p->itype == instI1Pro2)
+ len = 6;
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xC4, 0, 0, pbuf, len, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_readEEProm: read failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ /* Now read the bytes */
+ se = p->icom->usb_read(p->icom, NULL, 0x82, buf, size, &rwbytes, 5.0);
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_readEEProm: read failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ if (rwbytes != size) {
+ a1logd(p->log,1,"i1pro_readEEProm: 0x%x bytes, short read error\n",rwbytes);
+ return I1PRO_HW_EE_SHORTREAD;
+ }
+
+ if (p->log->debug >= 7) {
+ int i;
+ char oline[100], *bp = oline;
+ for (i = 0; i < size; i++) {
+ if ((i % 16) == 0)
+ bp += sprintf(bp," %04x:",i);
+ bp += sprintf(bp," %02x",buf[i]);
+ if ((i+1) >= size || ((i+1) % 16) == 0) {
+ bp += sprintf(bp,"\n");
+ a1logd(p->log,7,oline);
+ bp = oline;
+ }
+ }
+ }
+
+ a1logd(p->log,2,"i1pro_readEEProm: 0x%x bytes, ICOM err 0x%x (%d msec)\n",
+ rwbytes, se, msec_time()-stime);
+
+ return rv;
+}
+
+/* Write to the EEProm */
+i1pro_code
+i1pro_writeEEProm(
+ i1pro *p,
+ unsigned char *buf, /* Where to write from */
+ int addr, /* Address in EEprom to write to */
+ int size /* Number of bytes to write (max 65535) */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ int rwbytes; /* Data bytes read or written */
+ unsigned char pbuf[8]; /* Write EEprom parameters */
+ int len = 8; /* Message length */
+ int se = 0, rv = I1PRO_OK;
+ int i;
+ int stime;
+
+ /* Don't write over fixed values, as the instrument could become unusable.. */
+ if (addr < 0 || addr > 0x1000 || (addr + size) >= 0x1000)
+ return I1PRO_INT_EETOOBIG;
+
+ a1logd(p->log,2,"i1pro_writeEEProm: address 0x%x size 0x%x @ %d msec\n",
+ addr,size, (stime = msec_time()) - m->msec);
+
+ if (p->log->debug >= 6) {
+ int i;
+ char oline[100], *bp = oline;
+ for (i = 0; i < size; i++) {
+ if ((i % 16) == 0)
+ bp += sprintf(bp," %04x:",i);
+ bp += sprintf(bp," %02x",buf[i]);
+ if ((i+1) >= size || ((i+1) % 16) == 0) {
+ bp += sprintf(bp,"\n");
+ a1logd(p->log,6,oline);
+ bp = oline;
+ }
+ }
+ }
+
+#ifdef ENABLE_WRITE
+ int2buf(&pbuf[0], addr);
+ short2buf(&pbuf[4], size);
+ short2buf(&pbuf[6], 0x100); /* Might be accidental, left over from getmisc.. */
+
+ if (p->itype == instI1Pro2)
+ len = 6;
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xC3, 0, 0, pbuf, len, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_writeEEProm: write failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ /* Now write the bytes */
+ se = p->icom->usb_write(p->icom, NULL, 0x03, buf, size, &rwbytes, 5.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_writeEEProm: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ if (rwbytes != size) {
+ a1logd(p->log,1,"i1pro_writeEEProm: 0x%x bytes, short write error\n",rwbytes);
+ return I1PRO_HW_EE_SHORTWRITE;
+ }
+
+ /* Now we write two separate bytes of 0 - confirm write ?? */
+ for (i = 0; i < 2; i++) {
+ pbuf[0] = 0;
+
+ /* Now write the bytes */
+ se = p->icom->usb_write(p->icom, NULL, 0x03, pbuf, 1, &rwbytes, 5.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_writeEEProm: write failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ if (rwbytes != 1) {
+ a1logd(p->log,1,"i1pro_writeEEProm: 0x%x bytes, short write error\n",rwbytes);
+ return I1PRO_HW_EE_SHORTWRITE;
+ }
+ }
+ a1logd(p->log,2,"i1pro_writeEEProm: 0x%x bytes, ICOM err 0x%x (%d msec)\n",
+ size, se, msec_time()-stime);
+
+ /* The instrument needs some recovery time after a write */
+ msec_sleep(50);
+
+#else /* ENABLE_WRITE */
+
+ a1logd(p->log,2,"i1pro_writeEEProm: (NOT) 0x%x bytes, ICOM err 0x%x\n",size, se);
+
+#endif /* ENABLE_WRITE */
+
+ return rv;
+}
+
+/* Get the miscellaneous status */
+/* return pointers may be NULL if not needed. */
+i1pro_code
+i1pro_getmisc(
+ i1pro *p,
+ int *fwrev, /* Return the hardware version number */
+ int *unkn1, /* Unknown status, set after doing a measurement */
+ int *maxpve, /* Maximum positive value in sensor readings */
+ int *unkn3, /* Unknown status, usually 1 */
+ int *powmode /* 0 = high power mode, 8 = low power mode */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[8]; /* status bytes read */
+ int _fwrev;
+ int _unkn1;
+ int _maxpve;
+ int _unkn3;
+ int _powmode;
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_getmisc: @ %d msec\n",(stime = msec_time()) - m->msec);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xC9, 0, 0, pbuf, 8, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_getmisc: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ _fwrev = buf2ushort(&pbuf[0]);
+ _unkn1 = buf2ushort(&pbuf[2]); /* Value set after each read. Average ?? */
+ _maxpve = buf2ushort(&pbuf[4]);
+ _unkn3 = pbuf[6]; /* Flag values are tested, but don't seem to be used ? */
+ _powmode = pbuf[7];
+
+ a1logd(p->log,2,"i1pro_getmisc: returning %d, 0x%04x, 0x%04x, 0x%02x, 0x%02x ICOM err 0x%x (%d msec)\n",
+ _fwrev, _unkn1, _maxpve, _unkn3, _powmode, se, msec_time()-stime);
+
+ if (fwrev != NULL) *fwrev = _fwrev;
+ if (unkn1 != NULL) *unkn1 = _unkn1;
+ if (maxpve != NULL) *maxpve = _maxpve;
+ if (unkn3 != NULL) *unkn3 = _unkn3;
+ if (powmode != NULL) *powmode = _powmode;
+
+ return rv;
+}
+
+/* Get the current measurement parameters */
+/* Return pointers may be NULL if not needed. */
+i1pro_code
+i1pro_getmeasparams(
+ i1pro *p,
+ int *intclocks, /* Number of integration clocks */
+ int *lampclocks, /* Number of lamp turn on sub-clocks */
+ int *nummeas, /* Number of measurements */
+ int *measmodeflags /* Measurement mode flags */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[8]; /* status bytes read */
+ int _intclocks;
+ int _lampclocks;
+ int _nummeas;
+ int _measmodeflags;
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_getmeasparams: @ %d msec\n", (stime = msec_time()) - m->msec);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xC2, 0, 0, pbuf, 8, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_getmeasparams: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ _intclocks = buf2ushort(&pbuf[0]);
+ _lampclocks = buf2ushort(&pbuf[2]);
+ _nummeas = buf2ushort(&pbuf[4]);
+ _measmodeflags = pbuf[6];
+
+ a1logd(p->log,2,"i1pro_getmeasparams: returning %d, %d, %d, 0x%02x ICOM err 0x%x (%d msec)\n",
+ _intclocks, _lampclocks, _nummeas, _measmodeflags, se, msec_time()-stime);
+
+ if (intclocks != NULL) *intclocks = _intclocks;
+ if (lampclocks != NULL) *lampclocks = _lampclocks;
+ if (nummeas != NULL) *nummeas = _nummeas;
+ if (measmodeflags != NULL) *measmodeflags = _measmodeflags;
+
+ return rv;
+}
+
+/* Set the current measurement parameters */
+/* Return pointers may be NULL if not needed. */
+/* Quirks:
+
+ Rev. A upgrade:
+ Rev. B:
+ Appears to have a bug where the measurement time
+ is the sum of the previous measurement plus the current measurement.
+ It doesn't seem to alter the integration time though.
+ There is no obvious way of fixing this (ie. reseting the instrument
+ doesn't work).
+
+ Rev. D:
+ It appears that setting intclocks to 0, toggles to/from
+ a half clock speed mode. (?)
+*/
+
+i1pro_code
+i1pro_setmeasparams(
+ i1pro *p,
+ int intclocks, /* Number of integration clocks */
+ int lampclocks, /* Number of lamp turn on sub-clocks */
+ int nummeas, /* Number of measurements */
+ int measmodeflags /* Measurement mode flags */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[8]; /* command bytes written */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_setmeasparams: %d, %d, %d, 0x%02x @ %d msec\n",
+ intclocks, lampclocks, nummeas, measmodeflags,
+ (stime = msec_time()) - m->msec);
+
+ short2buf(&pbuf[0], intclocks);
+ short2buf(&pbuf[2], lampclocks);
+ short2buf(&pbuf[4], nummeas);
+ pbuf[6] = measmodeflags;
+ pbuf[7] = 0;
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xC1, 0, 0, pbuf, 8, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_setmeasparams: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ a1logd(p->log,2,"i1pro_setmeasparams: returning ICOM err 0x%x (%d msec)\n",
+ se,msec_time()-stime);
+ return rv;
+}
+
+/* Delayed trigger implementation, called from thread */
+static int
+i1pro_delayed_trigger(void *pp) {
+ i1pro *p = (i1pro *)pp;
+ i1proimp *m = (i1proimp *)p->m;
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) { /* Lamp will be on for measurement */
+ m->llampoffon = msec_time(); /* Record when it turned on */
+// printf("~1 got lamp off -> on at %d (%f)\n",m->llampoffon, (m->llampoffon - m->llamponoff)/1000.0);
+
+ }
+
+ a1logd(p->log,2,"i1pro_delayed_trigger: start sleep @ %d msec\n", msec_time() - m->msec);
+
+ /* Delay the trigger */
+ msec_sleep(m->trig_delay);
+
+ m->tr_t1 = msec_time(); /* Diagnostic */
+
+ a1logd(p->log,2,"i1pro_delayed_trigger: trigger @ %d msec\n",(stime = msec_time()) - m->msec);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xC0, 0, 0, NULL, 0, 2.0);
+
+ m->tr_t2 = msec_time(); /* Diagnostic */
+
+ m->trig_se = se;
+ m->trig_rv = icoms2i1pro_err(se);
+
+ a1logd(p->log,2,"i1pro_delayed_trigger: returning ICOM err 0x%x (%d msec)\n",
+ se,msec_time()-stime);
+
+ return 0;
+}
+
+/* Trigger a measurement after the nominated delay */
+/* The actual return code will be in m->trig_rv after the delay. */
+/* This allows us to start the measurement read before the trigger, */
+/* ensuring that process scheduling latency can't cause the read to fail. */
+i1pro_code
+i1pro_triggermeasure(i1pro *p, int delay) {
+ i1proimp *m = (i1proimp *)p->m;
+ int rv = I1PRO_OK;
+
+ a1logd(p->log,2,"i1pro_triggermeasure: trigger after %dmsec delay @ %d msec\n",
+ delay, msec_time() - m->msec);
+
+ /* NOTE := would be better here to create thread once, and then trigger it */
+ /* using a condition variable. */
+ if (m->trig_thread != NULL)
+ m->trig_thread->del(m->trig_thread);
+
+ m->tr_t1 = m->tr_t2 = m->tr_t3 = m->tr_t4 = m->tr_t5 = m->tr_t6 = m->tr_t7 = 0;
+ m->trig_delay = delay;
+
+ if ((m->trig_thread = new_athread(i1pro_delayed_trigger, (void *)p)) == NULL) {
+ a1logd(p->log,1,"i1pro_triggermeasure: creating delayed trigger thread failed\n");
+ return I1PRO_INT_THREADFAILED;
+ }
+
+#ifdef WAIT_FOR_DELAY_TRIGGER /* hack to diagnose threading problems */
+ while (m->tr_t2 == 0) {
+ Sleep(1);
+ }
+#endif
+ a1logd(p->log,2,"i1pro_triggermeasure: scheduled triggering OK\n");
+
+ return rv;
+}
+
+/* Read a measurements results. */
+/* A buffer full of bytes is returned. */
+/* (This will fail on a Rev. A if there is more than about a 40 msec delay */
+/* between triggering the measurement and starting this read. */
+/* It appears though that the read can be pending before triggering though. */
+/* Scan reads will also terminate if there is too great a delay beteween each read.) */
+i1pro_code
+i1pro_readmeasurement(
+ i1pro *p,
+ int inummeas, /* Initial number of measurements to expect */
+ int scanflag, /* NZ if in scan mode to continue reading */
+ unsigned char *buf, /* Where to read it to */
+ int bsize, /* Bytes available in buffer */
+ int *nummeas, /* Return number of readings measured */
+ i1p_mmodif mmodif /* Measurement modifier enum */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char *ibuf = buf; /* Incoming buffer */
+ int nmeas; /* Number of measurements for this read */
+ double top, extra; /* Time out period */
+ int rwbytes; /* Data bytes read or written */
+ int se, rv = I1PRO_OK;
+ int treadings = 0;
+ int stime = 0;
+// int gotshort = 0; /* nz when got a previous short reading */
+
+ if ((bsize % (m->nsen * 2)) != 0) {
+ return I1PRO_INT_ODDREADBUF;
+ }
+
+ a1logd(p->log,2,"i1pro_readmeasurement: inummeas %d, scanflag %d, address %p bsize 0x%x "
+ "@ %d msec\n",inummeas, scanflag, buf, bsize, (stime = msec_time()) - m->msec);
+
+ extra = 2.0; /* Extra timeout margin */
+
+ /* Deal with Rev A+ & Rev B quirk: */
+ if ((m->fwrev >= 200 && m->fwrev < 300)
+ || (m->fwrev >= 300 && m->fwrev < 400))
+ extra += m->l_inttime;
+ m->l_inttime = m->c_inttime;
+
+#ifdef SINGLE_READ
+ if (scanflag == 0)
+ nmeas = inummeas;
+ else
+ nmeas = bsize / (m->nsen * 2); /* Use a single large read */
+#else
+ nmeas = inummeas; /* Smaller initial number of measurements */
+#endif
+
+ top = extra + m->c_inttime * nmeas;
+ if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) /* Lamp is on */
+ top += m->c_lamptime;
+
+ /* NOTE :- for a scan on Rev. A, if we don't read fast enough the Eye-One will */
+ /* assume it should stop sending, even though the user has the switch pressed. */
+ /* For the rev A, this is quite a small margin (aprox. 1 msec ?) */
+ /* The Rev D has a lot more buffering, and is quite robust. */
+ /* By using the delayed trigger and a single read, this problem is usually */
+ /* eliminated. */
+ /* An unexpected short read seems to lock the instrument up. Not currently */
+ /* sure what sequence would recover it for a retry of the read. */
+ for (;;) {
+ int size; /* number of bytes to read */
+
+ size = m->nsen * 2 * nmeas;
+
+ if (size > bsize) { /* oops, no room for read */
+ a1logd(p->log,1,"i1pro_readmeasurement: buffer was too short for scan\n");
+ return I1PRO_INT_MEASBUFFTOOSMALL;
+ }
+
+ m->tr_t6 = msec_time(); /* Diagnostic, start of subsequent reads */
+ if (m->tr_t3 == 0) m->tr_t3 = m->tr_t6; /* Diagnostic, start of first read */
+
+ se = p->icom->usb_read(p->icom, NULL, 0x82, buf, size, &rwbytes, top);
+
+ m->tr_t5 = m->tr_t7;
+ m->tr_t7 = msec_time(); /* Diagnostic, end of subsequent reads */
+ if (m->tr_t4 == 0) {
+ m->tr_t5 = m->tr_t2;
+ m->tr_t4 = m->tr_t7; /* Diagnostic, end of first read */
+ }
+
+#ifdef NEVER /* Use short + timeout to terminate scan */
+ if (gotshort != 0 && se == ICOM_TO) { /* We got a timeout after a short read. */
+ a1logd(p->log,2,"i1pro_readmeasurement: timed out in %f secs after getting short read\n",top);
+ a1logd(p->log,2,"i1pro_readmeasurement: trig & rd times %d %d %d %d)\n",
+ m->tr_t2-m->tr_t1, m->tr_t3-m->tr_t2, m->tr_t4-m->tr_t3, m->tr_t6-m->tr_t5);
+ break; /* We're done */
+ } else
+#endif
+ if (se == ICOM_SHORT) { /* Expect this to terminate scan reading */
+ a1logd(p->log,2,"i1pro_readmeasurement: short read, read %d bytes, asked for %d\n",
+ rwbytes,size);
+ a1logd(p->log,2,"i1pro_readmeasurement: trig & rd times %d %d %d %d)\n",
+ m->tr_t2-m->tr_t1, m->tr_t3-m->tr_t2, m->tr_t4-m->tr_t3, m->tr_t6-m->tr_t5);
+ } else if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ if (m->trig_rv != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_readmeasurement: trigger failed, ICOM err 0x%x\n",
+ m->trig_se);
+ return m->trig_rv;
+ }
+ if (se & ICOM_TO)
+ a1logd(p->log,1,"i1pro_readmeasurement: timed out with top = %f\n",top);
+ a1logd(p->log,1,"i1pro_readmeasurement: failed, bytes read 0x%x, ICOM err 0x%x\n",
+ rwbytes, se);
+ return rv;
+ }
+
+ /* If we didn't read a multiple of m->nsen * 2, we've got problems */
+ if ((rwbytes % (m->nsen * 2)) != 0) {
+ a1logd(p->log,1,"i1pro_readmeasurement: read 0x%x bytes, odd read error\n",rwbytes);
+ return I1PRO_HW_ME_ODDREAD;
+ }
+
+ /* Track where we're up to */
+ bsize -= rwbytes;
+ buf += rwbytes;
+ treadings += rwbytes/(m->nsen * 2);
+
+ if (scanflag == 0) { /* Not scanning */
+
+ /* Expect to read exactly what we asked for */
+ if (rwbytes != size) {
+ a1logd(p->log,1,"i1pro_readmeasurement: unexpected short read, got %d expected %d\n"
+ ,rwbytes,size);
+ return I1PRO_HW_ME_SHORTREAD;
+ }
+ break; /* And we're done */
+ }
+
+#ifdef NEVER /* Use short + timeout to terminate scan */
+ /* We expect to get a short read at the end of a scan, */
+ /* or we might have the USB transfer truncated by somethinge else. */
+ /* Note the short read, and keep reading until we get a time out */
+ if (rwbytes != size) {
+ gotshort = 1;
+ } else {
+ gotshort = 0;
+ }
+#else /* Use short to terminate scan */
+ /* We're scanning and expect to get a short read at the end of the scan. */
+ if (rwbytes != size) {
+ break;
+ }
+#endif
+
+ if (bsize == 0) { /* oops, no room for more scanning read */
+ unsigned char tbuf[NSEN_MAX * 2];
+
+ /* We need to clean up, so soak up all the data and throw it away */
+ while ((se = p->icom->usb_read(p->icom, NULL, 0x82, tbuf, m->nsen * 2, &rwbytes, top)) == ICOM_OK)
+ ;
+ a1logd(p->log,1,"i1pro_readmeasurement: buffer was too short for scan\n");
+ return I1PRO_INT_MEASBUFFTOOSMALL;
+ }
+
+ /* Read a bunch more readings until the read is short or times out */
+ nmeas = bsize / (m->nsen * 2);
+ if (nmeas > 64)
+ nmeas = 64;
+ top = extra + m->c_inttime * nmeas;
+ }
+
+ if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) { /* Lamp was on for measurement */
+ m->slamponoff = m->llamponoff; /* remember second last */
+ m->llamponoff = msec_time(); /* Record when it turned off */
+// printf("~1 got lamp on -> off at %d (%f)\n",m->llamponoff, (m->llamponoff - m->llampoffon)/1000.0);
+ m->lampage += (m->llamponoff - m->llampoffon)/1000.0; /* Time lamp was on */
+ }
+ /* Update log values */
+ if (mmodif != i1p_dark_cal)
+ m->meascount++;
+
+ /* Must have timed out in initial readings */
+ if (treadings < inummeas) {
+ a1logd(p->log,1,"i1pro_readmeasurement: read failed, bytes read 0x%x, ICOM err 0x%x\n",
+ rwbytes, se);
+ return I1PRO_RD_SHORTMEAS;
+ }
+
+ if (p->log->debug >= 6) {
+ int i, size = treadings * m->nsen * 2;
+ char oline[100], *bp = oline;
+ for (i = 0; i < size; i++) {
+ if ((i % 16) == 0)
+ bp += sprintf(bp," %04x:",i);
+ bp += sprintf(bp," %02x",ibuf[i]);
+ if ((i+1) >= size || ((i+1) % 16) == 0) {
+ bp += sprintf(bp,"\n");
+ a1logd(p->log,6,oline);
+ bp = oline;
+ }
+ }
+ }
+
+ a1logd(p->log,2,"i1pro_readmeasurement: read %d readings, ICOM err 0x%x (%d msec)\n",
+ treadings, se, msec_time()-stime);
+ a1logd(p->log,2,"i1pro_readmeasurement: (trig & rd times %d %d %d %d)\n",
+ m->tr_t2-m->tr_t1, m->tr_t3-m->tr_t2, m->tr_t4-m->tr_t3, m->tr_t6-m->tr_t5);
+
+ if (nummeas != NULL) *nummeas = treadings;
+
+ return rv;
+}
+
+/* Set the measurement clock mode */
+/* Firmware Version >= 301 only */
+i1pro_code
+i1pro_setmcmode(
+ i1pro *p,
+ int mcmode /* Measurement clock mode, 1..mxmcmode */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[1]; /* 1 bytes to write */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_setmcmode: mode %d @ %d msec\n",
+ mcmode, (stime = msec_time()) - m->msec);
+
+ pbuf[0] = mcmode;
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xCF, 0, 0, pbuf, 1, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_setmcmode: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ a1logd(p->log,2,"i1pro_setmcmode: done, ICOM err 0x%x (%d msec)\n",
+ se, msec_time()-stime);
+ return rv;
+}
+
+/* Get the current measurement clock mode */
+/* Return pointers may be NULL if not needed. */
+/* Firmware Version >= 301 only */
+i1pro_code
+i1pro_getmcmode(
+ i1pro *p,
+ int *maxmcmode, /* mcmode must be <= maxmcmode */
+ int *mcmode, /* readback current mcmode */
+ int *subclkdiv, /* Sub clock divider ratio */
+ int *intclkusec, /* Integration clock in usec */
+ int *subtmode /* Subtract mode on read using average of value 127 */
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[8]; /* status bytes read */
+ int _maxmcmode; /* mcmode must be < maxmcmode */
+ int _mcmode; /* readback current mcmode */
+ int _unknown; /* Unknown */
+ int _subclkdiv; /* Sub clock divider ratio */
+ int _intclkusec; /* Integration clock in usec */
+ int _subtmode; /* Subtract mode on read using average of value 127 */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_getmcmode: called @ %d msec\n",
+ (stime = msec_time()) - m->msec);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD1, 0, 0, pbuf, 6, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_getmcmode: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ _maxmcmode = pbuf[0];
+ _mcmode = pbuf[1];
+ _unknown = pbuf[2];
+ _subclkdiv = pbuf[3];
+ _intclkusec = pbuf[4];
+ _subtmode = pbuf[5];
+
+ a1logd(p->log,2,"i1pro_getmcmode: returns %d, %d, (%d), %d, %d 0x%x ICOM err 0x%x (%d msec)\n",
+ _maxmcmode, _mcmode, _unknown, _subclkdiv, _intclkusec, _subtmode, se, msec_time()-stime);
+
+ if (maxmcmode != NULL) *maxmcmode = _maxmcmode;
+ if (mcmode != NULL) *mcmode = _mcmode;
+ if (subclkdiv != NULL) *subclkdiv = _subclkdiv;
+ if (intclkusec != NULL) *intclkusec = _intclkusec;
+ if (subtmode != NULL) *subtmode = _subtmode;
+
+ return rv;
+}
+
+
+/* Wait for a reply triggered by an instrument switch press */
+i1pro_code i1pro_waitfor_switch(i1pro *p, double top) {
+ i1proimp *m = (i1proimp *)p->m;
+ int rwbytes; /* Data bytes read */
+ unsigned char buf[8]; /* Result */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_waitfor_switch: read 1 byte from switch hit port @ %d msec\n",
+ (stime = msec_time()) - m->msec);
+
+ /* Now read 1 byte */
+ se = p->icom->usb_read(p->icom, NULL, 0x84, buf, 1, &rwbytes, top);
+
+ if (se & ICOM_TO) {
+ a1logd(p->log,2,"i1pro_waitfor_switch: read 0x%x bytes, timed out (%d msec)\n",
+ rwbytes,msec_time()-stime);
+ return I1PRO_INT_BUTTONTIMEOUT;
+ }
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro_waitfor_switch: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ if (rwbytes != 1) {
+ a1logd(p->log,1,"i1pro_waitfor_switch: read 0x%x bytes, short read error (%d msec)\n",
+ rwbytes,msec_time()-stime);
+ return I1PRO_HW_SW_SHORTREAD;
+ }
+
+ a1logd(p->log,2,"i1pro_waitfor_switch: read 0x%x bytes value 0x%x ICOM err 0x%x (%d msec)\n",
+ rwbytes, buf[0], se, msec_time()-stime);
+
+ return rv;
+}
+
+/* Wait for a reply triggered by a key press (thread version) */
+/* Returns I1PRO_OK if the switch has been pressed, */
+/* or I1PRO_INT_BUTTONTIMEOUT if */
+/* no switch was pressed befor the time expired, */
+/* or some other error. */
+i1pro_code i1pro_waitfor_switch_th(i1pro *p, double top) {
+ i1proimp *m = (i1proimp *)p->m;
+ int rwbytes; /* Data bytes read */
+ unsigned char buf[8]; /* Result */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ a1logd(p->log,2,"i1pro_waitfor_switch_th: read 1 byte from switch hit port @ %d msec\n",
+ (stime = msec_time()) - m->msec);
+
+ /* Now read 1 byte */
+ se = p->icom->usb_read(p->icom, &m->cancelt, 0x84, buf, 1, &rwbytes, top);
+
+ if (se & ICOM_TO) {
+ a1logd(p->log,2,"i1pro_waitfor_switch_th: read 0x%x bytes, timed out (%d msec)\n",
+ rwbytes,msec_time()-stime);
+ return I1PRO_INT_BUTTONTIMEOUT;
+ }
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_waitfor_switch_th: failed with ICOM err 0x%x (%d msec)\n",
+ se,msec_time()-stime);
+ return rv;
+ }
+
+ if (rwbytes != 1) {
+ a1logd(p->log,2,"i1pro_waitfor_switch_th: read 0x%x bytes, short read error (%d msec)\n",
+ rwbytes,msec_time()-stime);
+ return I1PRO_HW_SW_SHORTREAD;
+ }
+
+ a1logd(p->log,2,"i1pro_waitfor_switch_th: read 0x%x bytes value 0x%x ICOM err 0x%x (%d msec)\n",
+ rwbytes, buf[0], se,msec_time()-stime);
+
+ return rv;
+}
+
+/* Terminate switch handling */
+/* This seems to always return an error ? */
+i1pro_code
+i1pro_terminate_switch(
+ i1pro *p
+) {
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[8]; /* 8 bytes to write */
+ int se, rv = I1PRO_OK;
+
+ a1logd(p->log,2,"i1pro_terminate_switch: called\n");
+
+ /* These values may not be significant */
+ pbuf[0] = pbuf[1] = pbuf[2] = pbuf[3] = 0xff;
+ pbuf[4] = 0xfc;
+ pbuf[5] = 0xee;
+ pbuf[6] = 0x12;
+ pbuf[7] = 0x00;
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD0, 3, 0, pbuf, 8, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1pro_terminate_switch: Warning: Terminate Switch Handling failed with ICOM err 0x%x\n",se);
+ } else {
+ a1logd(p->log,2,"i1pro_terminate_switch: done, ICOM err 0x%x\n",se);
+ }
+
+ /* In case the above didn't work, cancel the I/O */
+ msec_sleep(50);
+ if (m->th_termed == 0) {
+ a1logd(p->log,3,"i1pro terminate switch thread failed, canceling I/O\n");
+ p->icom->usb_cancel_io(p->icom, &m->cancelt);
+ }
+
+ return rv;
+}
+
+/* ============================================================ */
+/* Low level i1pro2 (Rev E) commands */
+
+/* Get the EEProm size */
+i1pro_code
+i1pro2_geteesize(
+ i1pro *p,
+ int *eesize
+) {
+ int se, rv = I1PRO_OK;
+ unsigned char buf[4]; /* Result */
+ int _eesize = 0;
+
+ a1logd(p->log,2,"i1pro2_geteesize: called\n");
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD9, 0, 0, buf, 4, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_geteesize: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ _eesize = buf2int(buf);
+
+ a1logd(p->log,2,"i1pro2_geteesize: returning %d ICOM err 0x%x\n", _eesize, se);
+
+ if (eesize != NULL)
+ *eesize = _eesize;
+
+ return rv;
+}
+
+/* Get the Chip ID */
+/* This does actually work with the Rev D. */
+/* (It returns all zero's unless you've read the EEProm first !) */
+i1pro_code
+i1pro2_getchipid(
+ i1pro *p,
+ unsigned char chipid[8]
+) {
+ int se, rv = I1PRO_OK;
+
+ a1logd(p->log,2,"i1pro2_getchipid: called\n");
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD2, 0, 0, chipid, 8, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_getchipid: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ a1logd(p->log,2,"i1pro2_getchipid: returning %02X-%02X%02X%02X%02X%02X%02X%02X ICOM err 0x%x\n",
+ chipid[0], chipid[1], chipid[2], chipid[3],
+ chipid[4], chipid[5], chipid[6], chipid[7], se);
+ return rv;
+}
+
+/* Get Rev E measure characteristics. */
+i1pro_code
+i1pro2_getmeaschar(
+ i1pro *p,
+ int *clkusec, /* Return integration clock length in usec ? (ie. 36) */
+ int *xraw, /* Return number of extra non-reading (dark) raw bands ? (ie. 6) */
+ int *nraw, /* Return number of reading raw bands ? (ie. 128) */
+ int *subdiv /* Sub divider and minium integration clocks ? (ie. 136) */
+) {
+ int se, rv = I1PRO_OK;
+ unsigned char buf[16]; /* Result */
+ int _clkusec;
+ int _xraw;
+ int _nraw;
+ int _subdiv;
+
+ a1logd(p->log,2,"i1pro2_getmeaschar: called\n");
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD5, 0, 0, buf, 16, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_getmeaschar: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ _clkusec = buf2int(buf + 0);
+ _xraw = buf2int(buf + 4);
+ _nraw = buf2int(buf + 8);
+ _subdiv = buf2int(buf + 12);
+
+ a1logd(p->log,2,"i1pro2_getmeaschar: returning clkusec %d, xraw %d, nraw %d, subdiv %d ICOM err 0x%x\n", _clkusec, _xraw, _nraw, _subdiv, se);
+
+ if (clkusec != NULL)
+ *clkusec = _clkusec;
+ if (xraw != NULL)
+ *xraw = _xraw;
+ if (nraw != NULL)
+ *nraw = _nraw;
+ if (subdiv != NULL)
+ *subdiv = _subdiv;
+
+ return rv;
+}
+
+/* Delayed trigger implementation, called from thread */
+/* We assume that the Rev E measurement parameters have been set in */
+/* the i1proimp structure c_* values */
+static int
+i1pro2_delayed_trigger(void *pp) {
+ i1pro *p = (i1pro *)pp;
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[14]; /* 14 bytes to write */
+ int se, rv = I1PRO_OK;
+ int stime = 0;
+
+ int2buf(pbuf + 0, m->c_intclocks);
+ int2buf(pbuf + 4, m->c_lampclocks);
+ int2buf(pbuf + 8, m->c_nummeas);
+ short2buf(pbuf + 12, m->c_measmodeflags2);
+
+ if ((m->c_measmodeflags & I1PRO_MMF_NOLAMP) == 0) { /* Lamp will be on for measurement */
+ m->llampoffon = msec_time(); /* Record when it turned on */
+ }
+
+ a1logd(p->log,2,"i1pro2_delayed_trigger: Rev E start sleep @ %d msec\n",
+ msec_time() - m->msec);
+
+ /* Delay the trigger */
+ msec_sleep(m->trig_delay);
+
+ m->tr_t1 = msec_time(); /* Diagnostic */
+
+ a1logd(p->log,2,"i1pro2_delayed_trigger: trigger Rev E @ %d msec\n",
+ (stime = msec_time()) - m->msec);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD4, 0, 0, pbuf, 14, 2.0);
+
+ m->tr_t2 = msec_time(); /* Diagnostic */
+
+ m->trig_se = se;
+ m->trig_rv = icoms2i1pro_err(se);
+
+ a1logd(p->log,2,"i1pro2_delayed_trigger: done ICOM err 0x%x (%d msec)\n",
+ se,msec_time()-stime);
+ return 0;
+}
+
+/* Trigger a measurement after the nominated delay */
+/* The actual return code will be in m->trig_rv after the delay. */
+/* This allows us to start the measurement read before the trigger, */
+/* ensuring that process scheduling latency can't cause the read to fail. */
+i1pro_code
+i1pro2_triggermeasure(i1pro *p, int delay) {
+ i1proimp *m = (i1proimp *)p->m;
+ int rv = I1PRO_OK;
+
+ a1logd(p->log,2,"i1pro2_triggermeasure: triggering Rev Emeasurement after %dmsec "
+ "delay @ %d msec\n", delay, msec_time() - m->msec);
+
+ /* NOTE := would be better here to create thread once, and then trigger it */
+ /* using a condition variable. */
+ if (m->trig_thread != NULL)
+ m->trig_thread->del(m->trig_thread);
+
+ m->tr_t1 = m->tr_t2 = m->tr_t3 = m->tr_t4 = m->tr_t5 = m->tr_t6 = m->tr_t7 = 0;
+ m->trig_delay = delay;
+
+ if ((m->trig_thread = new_athread(i1pro2_delayed_trigger, (void *)p)) == NULL) {
+ a1logd(p->log,1,"i1pro2_triggermeasure: creating delayed trigger Rev E thread failed\n");
+ return I1PRO_INT_THREADFAILED;
+ }
+
+#ifdef WAIT_FOR_DELAY_TRIGGER /* hack to diagnose threading problems */
+ while (m->tr_t2 == 0) {
+ Sleep(1);
+ }
+#endif
+ a1logd(p->log,2,"i1pro2_triggermeasure: scheduled triggering Rev E OK\n");
+
+ return rv;
+}
+
+/* Get the UV before and after measurement voltage drop */
+i1pro_code
+i1pro2_getUVvolts(
+ i1pro *p,
+ int *before,
+ int *after
+) {
+ int se, rv = I1PRO_OK;
+ unsigned char buf[4]; /* Result */
+ int _before = 0;
+ int _after = 0;
+
+ a1logd(p->log,2,"i1pro2_getUVvolts: called\n");
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_IN | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD8, 0, 0, buf, 4, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_getUVvolts: failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ _before = buf2ushort(buf);
+ _after = buf2ushort(buf+2);
+
+ a1logd(p->log,2,"i1pro2_getUVvolts: returning %d, %d ICOM err 0x%x\n", _before, _after, se);
+
+ if (before != NULL)
+ *before = _before;
+
+ if (after != NULL)
+ *after = _after;
+
+ return rv;
+}
+
+/* Terminate Ruler tracking (???) */
+/* The parameter seems to be always 0 ? */
+static int
+i1pro2_stop_ruler(void *pp, int parm) {
+ i1pro *p = (i1pro *)pp;
+ i1proimp *m = (i1proimp *)p->m;
+ unsigned char pbuf[2]; /* 2 bytes to write */
+ int se, rv = I1PRO_OK;
+
+ short2buf(pbuf, parm);
+
+ a1logd(p->log,2,"i1pro2_stop_ruler: called with 0x%x\n", parm);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD7, 0, 0, pbuf, 2, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_stop_ruler: failed with ICOM err 0x%x\n",rv);
+ return rv;
+ }
+
+ a1logd(p->log,2,"i1pro2_stop_ruler: returning ICOM err 0x%x\n",rv);
+
+ return rv;
+}
+
+ /* Send a raw indicator LED sequence. */
+/*
+ The byte sequence has the following format:
+ (all values are big endian)
+
+ XXXX Number of following blocks, BE.
+
+ Blocks are:
+
+ YYYY Number of bytes in the block
+ RRRR Number of repeats of the block, FFFFFFFF = infinite
+
+ A sequence of codes:
+
+ LL TTTT
+ L = Led mask:
+ 01 = Red Right
+ 02 = Green Right
+ 04 = Blue Right
+ 08 = Red Left
+ 10 = Green Left
+ 20 = Blue Left
+ TTT = clock count for this mask (ie. aprox. 73 usec clock period)
+ PWM typically alternates between on & off state with a period total of
+ 0x50 clocks = 170 Hz. 255 clocks would be 54 Hz.
+
+ */
+
+static int
+i1pro2_indLEDseq(void *pp, unsigned char *buf, int size) {
+ i1pro *p = (i1pro *)pp;
+ i1proimp *m = (i1proimp *)p->m;
+ int rwbytes; /* Data bytes written */
+ unsigned char pbuf[4]; /* Number of bytes being send */
+ int se, rv = I1PRO_OK;
+
+ int2buf(pbuf, size);
+
+ a1logd(p->log,2,"i1pro2_indLEDseq: length %d bytes\n", size);
+
+ se = p->icom->usb_control(p->icom,
+ IUSB_ENDPOINT_OUT | IUSB_REQ_TYPE_VENDOR | IUSB_REQ_RECIP_DEVICE,
+ 0xD6, 0, 0, pbuf, 4, 2.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_indLEDseq: failed with ICOM err 0x%x\n",rv);
+ return rv;
+ }
+
+ a1logd(p->log,2,"i1pro2_geteesize: command got ICOM err 0x%x\n", se);
+
+ /* Now write the bytes */
+ se = p->icom->usb_write(p->icom, NULL, 0x03, buf, size, &rwbytes, 5.0);
+
+ if ((rv = icoms2i1pro_err(se)) != I1PRO_OK) {
+ a1logd(p->log,1,"i1pro2_indLEDseq: data write failed with ICOM err 0x%x\n",se);
+ return rv;
+ }
+
+ if (rwbytes != size) {
+ a1logd(p->log,1,"i1pro2_indLEDseq: wrote 0x%x bytes, short write error\n",rwbytes);
+ return I1PRO_HW_LED_SHORTWRITE;
+ }
+
+ a1logd(p->log,2,"i1pro2_indLEDseq: wrote 0x%x bytes LED sequence, ICOM err 0x%x\n", size, rv);
+
+ return rv;
+}
+
+/* Turn indicator LEDs off */
+static int
+i1pro2_indLEDoff(void *pp) {
+ i1pro *p = (i1pro *)pp;
+ int rv = I1PRO_OK;
+ unsigned char seq[] = {
+ 0x00, 0x00, 0x00, 0x01,
+
+ 0x00, 0x00, 0x00, 0x07,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x10
+ };
+
+ a1logd(p->log,2,"i1pro2_indLEDoff: called\n");
+ rv = i1pro2_indLEDseq(p, seq, sizeof(seq));
+ a1logd(p->log,2,"i1pro2_indLEDoff: returning ICOM err 0x%x\n",rv);
+
+ return rv;
+}
+
+#ifdef NEVER
+
+ // ~~99 play with LED settings
+ if (p->itype == instI1Pro2) {
+
+ // LED is capable of white and red
+
+ /* Turns it off */
+ unsigned char b1[] = {
+ 0x00, 0x00, 0x00, 0x01,
+
+ 0x00, 0x00, 0x00, 0x07,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x01
+ };
+
+ /* Makes it white */
+ unsigned char b2[] = {
+ 0x00, 0x00, 0x00, 0x02,
+
+ 0x00, 0x00, 0x00, 0x0a,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x36, 0x00,
+ 0x00, 0x00, 0x01,
+
+ 0x00, 0x00, 0x00, 0x0a,
+ 0xff, 0xff, 0xff, 0xff,
+ 0x3f, 0x36, 0x40,
+ 0x00, 0x00, 0x01
+ };
+
+ /* Makes it pulsing white */
+ unsigned char b3[] = {
+ 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x36, 0x40, 0x00,
+ 0x00, 0x01, 0x00, 0x00, 0x08, 0xec, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x03, 0x00,
+ 0x00, 0x4d, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x45, 0x3f, 0x00,
+ 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x4f,
+ 0x3f, 0x00, 0x04, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x04, 0x00,
+ 0x00, 0x46, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x41, 0x3f, 0x00,
+ 0x05, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x46,
+ 0x3f, 0x00, 0x05, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x06, 0x00,
+ 0x00, 0x4a, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x47, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x44, 0x3f, 0x00,
+ 0x06, 0x00, 0x00, 0x41, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x46,
+ 0x3f, 0x00, 0x07, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x07, 0x00,
+ 0x00, 0x3e, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x4a, 0x3f, 0x00,
+ 0x09, 0x00, 0x00, 0x47, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x0a, 0x00, 0x00, 0x49,
+ 0x3f, 0x00, 0x09, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0b, 0x00,
+ 0x00, 0x48, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x45, 0x3f, 0x00, 0x0a, 0x00, 0x00, 0x3c, 0x3f, 0x00,
+ 0x0c, 0x00, 0x00, 0x46, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x46,
+ 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3e, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x0d, 0x00,
+ 0x00, 0x3f, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3f, 0x3f, 0x00,
+ 0x0e, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3b, 0x3f, 0x00, 0x0f, 0x00, 0x00, 0x3d,
+ 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x0f, 0x00, 0x00, 0x39, 0x3f, 0x00, 0x10, 0x00,
+ 0x00, 0x3b, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x40, 0x3f, 0x00, 0x10, 0x00, 0x00, 0x37, 0x3f, 0x00,
+ 0x13, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x13, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x11, 0x00, 0x00, 0x34,
+ 0x3f, 0x00, 0x12, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x14, 0x00,
+ 0x00, 0x38, 0x3f, 0x00, 0x14, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x17, 0x00, 0x00, 0x3c, 0x3f, 0x00,
+ 0x17, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x18, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x15, 0x00, 0x00, 0x31,
+ 0x3f, 0x00, 0x17, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x16, 0x00, 0x00, 0x30, 0x3f, 0x00, 0x1a, 0x00,
+ 0x00, 0x37, 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x18, 0x00, 0x00, 0x2f, 0x3f, 0x00,
+ 0x1c, 0x00, 0x00, 0x35, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x33, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x31,
+ 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x31, 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1c, 0x00,
+ 0x00, 0x2c, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1e, 0x00, 0x00, 0x2c, 0x3f, 0x00,
+ 0x1d, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x1e, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x23, 0x00, 0x00, 0x2e,
+ 0x3f, 0x00, 0x22, 0x00, 0x00, 0x2b, 0x3f, 0x00, 0x25, 0x00, 0x00, 0x2d, 0x3f, 0x00, 0x24, 0x00,
+ 0x00, 0x2a, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x26, 0x3f, 0x00, 0x27, 0x00, 0x00, 0x2a, 0x3f, 0x00,
+ 0x22, 0x00, 0x00, 0x23, 0x3f, 0x00, 0x23, 0x00, 0x00, 0x23, 0x3f, 0x00, 0x2a, 0x00, 0x00, 0x28,
+ 0x3f, 0x00, 0x24, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x29, 0x00, 0x00, 0x24, 0x3f, 0x00, 0x2c, 0x00,
+ 0x00, 0x25, 0x3f, 0x00, 0x28, 0x00, 0x00, 0x20, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x21, 0x3f, 0x00,
+ 0x2d, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2a, 0x00, 0x00, 0x1c,
+ 0x3f, 0x00, 0x2f, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x2d, 0x00,
+ 0x00, 0x1a, 0x3f, 0x00, 0x31, 0x00, 0x00, 0x1b, 0x3f, 0x00, 0x2e, 0x00, 0x00, 0x18, 0x3f, 0x00,
+ 0x37, 0x00, 0x00, 0x1b, 0x3f, 0x00, 0x38, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x37, 0x00, 0x00, 0x18,
+ 0x3f, 0x00, 0x31, 0x00, 0x00, 0x14, 0x3f, 0x00, 0x39, 0x00, 0x00, 0x16, 0x3f, 0x00, 0x3d, 0x00,
+ 0x00, 0x16, 0x3f, 0x00, 0x36, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x3a, 0x00, 0x00, 0x12, 0x3f, 0x00,
+ 0x3b, 0x00, 0x00, 0x11, 0x3f, 0x00, 0x40, 0x00, 0x00, 0x11, 0x3f, 0x00, 0x3a, 0x00, 0x00, 0x0e,
+ 0x3f, 0x00, 0x3b, 0x00, 0x00, 0x0d, 0x3f, 0x00, 0x3c, 0x00, 0x00, 0x0c, 0x3f, 0x00, 0x3d, 0x00,
+ 0x00, 0x0b, 0x3f, 0x00, 0x3e, 0x00, 0x00, 0x0a, 0x3f, 0x00, 0x3f, 0x00, 0x00, 0x09, 0x3f, 0x00,
+ 0x40, 0x00, 0x00, 0x08, 0x3f, 0x00, 0x42, 0x00, 0x00, 0x07, 0x3f, 0x00, 0x44, 0x00, 0x00, 0x06,
+ 0x3f, 0x00, 0x47, 0x00, 0x00, 0x05, 0x3f, 0x00, 0x4b, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x50, 0x00,
+ 0x00, 0x03, 0x3f, 0x00, 0x44, 0x00, 0x00, 0x01, 0x3f, 0x00, 0x45, 0x3f, 0x00, 0x45, 0x3f, 0x00,
+ 0x45, 0x3f, 0x00, 0x45, 0x3f, 0x00, 0x44, 0x00, 0x00, 0x01, 0x3f, 0x00, 0x50, 0x00, 0x00, 0x03,
+ 0x3f, 0x00, 0x4b, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x47, 0x00, 0x00, 0x05, 0x3f, 0x00, 0x44, 0x00,
+ 0x00, 0x06, 0x3f, 0x00, 0x42, 0x00, 0x00, 0x07, 0x3f, 0x00, 0x40, 0x00, 0x00, 0x08, 0x3f, 0x00,
+ 0x3f, 0x00, 0x00, 0x09, 0x3f, 0x00, 0x3e, 0x00, 0x00, 0x0a, 0x3f, 0x00, 0x3d, 0x00, 0x00, 0x0b,
+ 0x3f, 0x00, 0x3c, 0x00, 0x00, 0x0c, 0x3f, 0x00, 0x3b, 0x00, 0x00, 0x0d, 0x3f, 0x00, 0x3a, 0x00,
+ 0x00, 0x0e, 0x3f, 0x00, 0x40, 0x00, 0x00, 0x11, 0x3f, 0x00, 0x3b, 0x00, 0x00, 0x11, 0x3f, 0x00,
+ 0x3a, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x36, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x3d, 0x00, 0x00, 0x16,
+ 0x3f, 0x00, 0x39, 0x00, 0x00, 0x16, 0x3f, 0x00, 0x31, 0x00, 0x00, 0x14, 0x3f, 0x00, 0x37, 0x00,
+ 0x00, 0x18, 0x3f, 0x00, 0x38, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x37, 0x00, 0x00, 0x1b, 0x3f, 0x00,
+ 0x2e, 0x00, 0x00, 0x18, 0x3f, 0x00, 0x31, 0x00, 0x00, 0x1b, 0x3f, 0x00, 0x2d, 0x00, 0x00, 0x1a,
+ 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1a, 0x3f, 0x00, 0x2f, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2a, 0x00,
+ 0x00, 0x1c, 0x3f, 0x00, 0x2b, 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x2d, 0x00, 0x00, 0x21, 0x3f, 0x00,
+ 0x2b, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x28, 0x00, 0x00, 0x20, 0x3f, 0x00, 0x2c, 0x00, 0x00, 0x25,
+ 0x3f, 0x00, 0x29, 0x00, 0x00, 0x24, 0x3f, 0x00, 0x24, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x2a, 0x00,
+ 0x00, 0x28, 0x3f, 0x00, 0x23, 0x00, 0x00, 0x23, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x23, 0x3f, 0x00,
+ 0x27, 0x00, 0x00, 0x2a, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x26, 0x3f, 0x00, 0x24, 0x00, 0x00, 0x2a,
+ 0x3f, 0x00, 0x25, 0x00, 0x00, 0x2d, 0x3f, 0x00, 0x22, 0x00, 0x00, 0x2b, 0x3f, 0x00, 0x23, 0x00,
+ 0x00, 0x2e, 0x3f, 0x00, 0x1e, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x29, 0x3f, 0x00,
+ 0x1e, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x2c,
+ 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x2c, 0x3f, 0x00, 0x1d, 0x00, 0x00, 0x31, 0x3f, 0x00, 0x1c, 0x00,
+ 0x00, 0x31, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x33, 0x3f, 0x00, 0x1c, 0x00, 0x00, 0x35, 0x3f, 0x00,
+ 0x18, 0x00, 0x00, 0x2f, 0x3f, 0x00, 0x1b, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x1a, 0x00, 0x00, 0x37,
+ 0x3f, 0x00, 0x16, 0x00, 0x00, 0x30, 0x3f, 0x00, 0x17, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x15, 0x00,
+ 0x00, 0x31, 0x3f, 0x00, 0x18, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x17, 0x00, 0x00, 0x3a, 0x3f, 0x00,
+ 0x17, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x14, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x14, 0x00, 0x00, 0x38,
+ 0x3f, 0x00, 0x12, 0x00, 0x00, 0x34, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x11, 0x00,
+ 0x00, 0x34, 0x3f, 0x00, 0x13, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x13, 0x00, 0x00, 0x3f, 0x3f, 0x00,
+ 0x10, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x12, 0x00, 0x00, 0x40, 0x3f, 0x00, 0x10, 0x00, 0x00, 0x3b,
+ 0x3f, 0x00, 0x0f, 0x00, 0x00, 0x39, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x37, 0x3f, 0x00, 0x0f, 0x00,
+ 0x00, 0x3d, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3b, 0x3f, 0x00, 0x0e, 0x00, 0x00, 0x3d, 0x3f, 0x00,
+ 0x0e, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x0d, 0x00, 0x00, 0x3f,
+ 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x3e, 0x3f, 0x00, 0x0d, 0x00,
+ 0x00, 0x46, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x0c, 0x00, 0x00, 0x46, 0x3f, 0x00,
+ 0x0a, 0x00, 0x00, 0x3c, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x45, 0x3f, 0x00, 0x0b, 0x00, 0x00, 0x48,
+ 0x3f, 0x00, 0x09, 0x00, 0x00, 0x3d, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x0a, 0x00,
+ 0x00, 0x49, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x09, 0x00, 0x00, 0x47, 0x3f, 0x00,
+ 0x09, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x3e,
+ 0x3f, 0x00, 0x08, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x07, 0x00,
+ 0x00, 0x46, 0x3f, 0x00, 0x07, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x41, 0x3f, 0x00,
+ 0x06, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x47, 0x3f, 0x00, 0x06, 0x00, 0x00, 0x4a,
+ 0x3f, 0x00, 0x06, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x05, 0x00,
+ 0x00, 0x46, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x05, 0x00, 0x00, 0x4d, 0x3f, 0x00,
+ 0x04, 0x00, 0x00, 0x41, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x46,
+ 0x3f, 0x00, 0x04, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x4d, 0x3f, 0x00, 0x04, 0x00,
+ 0x00, 0x4f, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x42, 0x3f, 0x00,
+ 0x03, 0x00, 0x00, 0x45, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x49, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x4d,
+ 0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x03, 0x00, 0x00, 0x50, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00,
+ 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43,
+ 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x43, 0x3f, 0x00, 0x02, 0x00,
+ 0x00, 0x43
+ };
+
+ unsigned char b4[] = {
+ 0x00, 0x00, 0x00, 0x01, // blocks
+
+ 0x00, 0x00, 0x00, 0x0a, // bytes
+ 0x00, 0x00, 0x00, 0x04, // repeat
+// 0xff, 0xff, 0xff, 0xff, // repeat
+// 0x3f, 0x00, 0x04, // Level ????
+// 0x00, 0x00, 0x3c // msec ????
+ 0x3f, 0x20, 0x00, // "
+ 0x00, 0x20, 0x00 // LED mask + clocks
+ };
+
+ printf("~1 send led sequence length %d\n",sizeof(b4));
+ if ((ev = i1pro2_indLEDseq(p, b4, sizeof(b4))) != I1PRO_OK)
+ return ev;
+ }
+#endif /* NEVER */
+
+/* ============================================================ */
+/* key/value dictionary support for EEProm contents */
+
+/* Search the linked list for the given key */
+/* Return NULL if not found */
+static i1keyv *i1data_find_key(i1data *d, i1key key) {
+ i1keyv *k;
+
+ for (k = d->head; k != NULL; k = k->next) {
+ if (k->key == key)
+ return k;
+ }
+ return NULL;
+}
+
+/* Search the linked list for the given key and */
+/* return it, or add it to the list if it doesn't exist. */
+/* Return NULL on error */
+static i1keyv *i1data_make_key(i1data *d, i1key key) {
+ i1keyv *k;
+
+ for (k = d->head; k != NULL; k = k->next)
+ if (k->key == key)
+ return k;
+
+ if ((k = (i1keyv *)calloc(1, sizeof(i1keyv))) == NULL) {
+ a1logw(d->log, "i1data: malloc failed!\n");
+ return NULL;
+ }
+
+ k->key = key;
+ k->next = NULL;
+ if (d->last == NULL) {
+ d->head = d->last = k;
+ } else {
+ d->last->next = k;
+ d->last = k;
+ }
+ return k;
+}
+
+/* Return type of data associated with key. Return i1_dtype_unknown if not found */
+static i1_dtype i1data_get_type(i1data *d, i1key key) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) != NULL)
+ return k->type;
+ return i1_dtype_unknown;
+}
+
+/* Return the number of data items in a keyv. Return 0 if not found */
+static unsigned int i1data_get_count(i1data *d, i1key key) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) != NULL)
+ return k->count;
+ return 0;
+}
+
+/* Return a pointer to the short data for the key. */
+/* Return NULL if not found or wrong type */
+static int *i1data_get_shorts(i1data *d, unsigned int *count, i1key key) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) == NULL)
+ return NULL;
+
+ if (k->type != i1_dtype_short)
+ return NULL;
+
+ if (count != NULL)
+ *count = k->count;
+
+ return (int *)k->data;
+}
+
+/* Return a pointer to the int data for the key. */
+/* Return NULL if not found or wrong type */
+static int *i1data_get_ints(i1data *d, unsigned int *count, i1key key) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) == NULL)
+ return NULL;
+
+ if (k->type != i1_dtype_int)
+ return NULL;
+
+ if (count != NULL)
+ *count = k->count;
+
+ return (int *)k->data;
+}
+
+/* Return a pointer to the double data for the key. */
+/* Return NULL if not found or wrong type */
+static double *i1data_get_doubles(i1data *d, unsigned int *count, i1key key) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) == NULL)
+ return NULL;
+
+ if (k->type != i1_dtype_double)
+ return NULL;
+
+ if (count != NULL)
+ *count = k->count;
+
+ return (double *)k->data;
+}
+
+
+/* Return pointer to one of the int data for the key. */
+/* Return NULL if not found or wrong type or out of range index. */
+static int *i1data_get_int(i1data *d, i1key key, unsigned int index) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) == NULL)
+ return NULL;
+
+ if (k->type != i1_dtype_int)
+ return NULL;
+
+ if (index >= k->count)
+ return NULL;
+
+ return ((int *)k->data) + index;
+}
+
+/* Return pointer to one of the double data for the key. */
+/* Return NULL if not found or wrong type or out of range index. */
+static double *i1data_get_double(i1data *d, i1key key, double *data, unsigned int index) {
+ i1keyv *k;
+
+ if ((k = d->find_key(d, key)) == NULL)
+ return NULL;
+
+ if (k->type != i1_dtype_double)
+ return NULL;
+
+ if (index >= k->count)
+ return NULL;
+
+ return ((double *)k->data) + index;
+}
+
+/* Un-serialize a char buffer into an i1key keyv */
+static i1pro_code i1data_unser_shorts(
+ i1data *d,
+ i1key key,
+ int addr,
+ unsigned char *buf,
+ unsigned int size
+) {
+ i1keyv *k;
+ int i, count;
+
+ count = size/2;
+
+ if (count == 0)
+ return I1PRO_DATA_COUNT;
+
+ if ((k = d->make_key(d, key)) == NULL)
+ return I1PRO_DATA_MAKE_KEY;
+
+ if (k->data != NULL)
+ free(k->data);
+
+ if ((k->data = (void *)malloc(sizeof(int) * count)) == NULL)
+ return I1PRO_DATA_MEMORY;
+
+ for (i = 0; i < count; i++, buf += 2) {
+ ((int *)k->data)[i] = buf2short(buf);
+ }
+
+ k->count = count;
+ k->size = size;
+ k->type = i1_dtype_short;
+ if (addr != -1)
+ k->addr = addr;
+
+ return I1PRO_OK;
+}
+
+/* Un-serialize a char buffer into an i1key keyv */
+static i1pro_code i1data_unser_ints(
+ i1data *d,
+ i1key key,
+ int addr,
+ unsigned char *buf,
+ unsigned int size
+) {
+ i1keyv *k;
+ int i, count;
+
+ count = size/4;
+
+ if (count == 0)
+ return I1PRO_DATA_COUNT;
+
+ if ((k = d->make_key(d, key)) == NULL)
+ return I1PRO_DATA_MAKE_KEY;
+
+ if (k->data != NULL)
+ free(k->data);
+
+ if ((k->data = (void *)malloc(sizeof(int) * count)) == NULL)
+ return I1PRO_DATA_MEMORY;
+
+ for (i = 0; i < count; i++, buf += 4) {
+ ((int *)k->data)[i] = buf2int(buf);
+ }
+
+ k->count = count;
+ k->size = size;
+ k->type = i1_dtype_int;
+ if (addr != -1)
+ k->addr = addr;
+
+ return I1PRO_OK;
+}
+
+/* Create an entry for an end of section marker */
+static i1pro_code i1data_add_eosmarker(
+ i1data *d,
+ i1key key, /* section number */
+ int addr
+) {
+ i1keyv *k;
+
+ if ((k = d->make_key(d, key)) == NULL)
+ return I1PRO_DATA_MAKE_KEY;
+
+ if (k->data != NULL) {
+ free(k->data);
+ k->data = NULL;
+ }
+
+ k->count = 0;
+ k->size = 0;
+ k->type = i1_dtype_section;
+ if (addr != -1)
+ k->addr = addr;
+
+ return I1PRO_OK;
+}
+
+/* Un-serialize a char buffer of floats into a double keyv */
+static i1pro_code i1data_unser_doubles(
+ i1data *d,
+ i1key key,
+ int addr,
+ unsigned char *buf,
+ unsigned int size
+) {
+ i1keyv *k;
+ int i, count;
+
+ count = size/4;
+
+ if (count == 0)
+ return I1PRO_DATA_COUNT;
+
+ if ((k = d->make_key(d, key)) == NULL)
+ return I1PRO_DATA_MAKE_KEY;
+
+ if (k->data != NULL)
+ free(k->data);
+
+ if ((k->data = (void *)malloc(sizeof(double) * count)) == NULL)
+ return I1PRO_DATA_MEMORY;
+
+ for (i = 0; i < count; i++, buf += 4) {
+ int val;
+ val = buf2int(buf);
+ ((double *)k->data)[i] = IEEE754todouble((unsigned int)val);
+ }
+
+ k->count = count;
+ k->size = size;
+ k->type = i1_dtype_double;
+ if (addr != -1)
+ k->addr = addr;
+
+ return I1PRO_OK;
+}
+
+
+/* Serialize an i1key keyv into a char buffer. Error if it is outside the buffer */
+static i1pro_code i1data_ser_ints(
+ i1data *d,
+ i1keyv *k,
+ unsigned char *buf,
+ unsigned int size
+) {
+ i1pro *p = d->p;
+ int i, len;
+
+ if (k->type != i1_dtype_int)
+ return I1PRO_DATA_WRONGTYPE;
+
+ len = k->count * 4;
+ if (len > k->size)
+ return I1PRO_DATA_BUFSIZE;
+
+ if (k->addr < 0 || k->addr >= size || (k->addr + k->size) > size)
+ return I1PRO_DATA_BUFSIZE;
+
+ buf += k->addr;
+ for (i = 0; i < k->count; i++, buf += 4) {
+ int2buf(buf, ((int *)k->data)[i]);
+ }
+
+ return I1PRO_OK;
+}
+
+/* Serialize a double keyv as floats into a char buffer. Error if the buf is not big enough */
+static i1pro_code i1data_ser_doubles(
+ i1data *d,
+ i1keyv *k,
+ unsigned char *buf,
+ unsigned int size
+) {
+ i1pro *p = d->p;
+ int i, len;
+
+ if (k->type != i1_dtype_double)
+ return I1PRO_DATA_WRONGTYPE;
+
+ len = k->count * 4;
+ if (len > k->size)
+ return I1PRO_DATA_BUFSIZE;
+
+ if (k->addr < 0 || k->addr >= size || (k->addr + k->size) > size)
+ return I1PRO_DATA_BUFSIZE;
+
+ buf += k->addr;
+ for (i = 0; i < k->count; i++, buf += 4) {
+ int2buf(buf, doubletoIEEE754(((double *)k->data)[i]));
+ }
+
+ return I1PRO_OK;
+}
+
+/* Copy an array full of ints to the key */
+/* Note the count must be the same as the existing key value, */
+/* since we are not prepared to re-allocate key/values within */
+/* the EEProm, or re-write the directory. */
+static i1pro_code i1data_add_ints(i1data *d, i1key key, int *data, unsigned int count) {
+ i1keyv *k;
+ int i;
+
+ if ((k = d->make_key(d, key)) == NULL)
+ return I1PRO_DATA_MAKE_KEY;
+
+ if (count != k->count)
+ return I1PRO_DATA_COUNT;
+
+ if (k->data != NULL)
+ free(k->data);
+
+ if ((k->data = (void *)malloc(sizeof(int) * count)) == NULL)
+ return I1PRO_DATA_MEMORY;
+
+ for (i = 0; i < count; i++) {
+ ((int *)k->data)[i] = data[i];
+ }
+
+ k->count = count;
+ k->type = i1_dtype_int;
+
+ return I1PRO_OK;
+}
+
+/* Copy an array full of doubles to the key */
+/* Note the count must be the same as the existing key value, */
+/* since we are not prepared to re-allocate key/values within */
+/* the EEProm, or re-write the directory. */
+static i1pro_code i1data_add_doubles(i1data *d, i1key key, double *data, unsigned int count) {
+ i1keyv *k;
+ int i;
+
+ if ((k = d->make_key(d, key)) == NULL)
+ return I1PRO_DATA_MAKE_KEY;
+
+ if (count != k->count)
+ return I1PRO_DATA_COUNT;
+
+ if (k->data != NULL)
+ free(k->data);
+
+ if ((k->data = (void *)malloc(sizeof(double) * count)) == NULL)
+ return I1PRO_DATA_MEMORY;
+
+ for (i = 0; i < count; i++) {
+ ((double *)k->data)[i] = data[i];
+ }
+
+ k->count = count;
+ k->type = i1_dtype_double;
+
+ return I1PRO_OK;
+}
+
+/* Initialise the data from the EEProm contents */
+static i1pro_code i1data_parse_eeprom(i1data *d, unsigned char *buf, unsigned int len, int extra) {
+ i1pro *p = d->p;
+ int rv = I1PRO_OK;
+ int dir = 0x1000; /* Location of key directory */
+ int block_id; /* Block id */
+ int nokeys;
+ i1key key, off, nkey = 0, noff = 0;
+ int size; /* size of key in bytes */
+ unsigned char *bp;
+ int i;
+
+ if (extra)
+ dir = 0x2000; /* Directory is at half way in i1pro2 2nd table */
+
+ a1logd(p->log,3,"i1pro_parse_eeprom called with %d bytes\n",len);
+
+ /* Room for minimum number of keys ? */
+ if ((dir + 300) > len)
+ return I1PRO_DATA_KEY_COUNT;
+
+ block_id = buf2ushort(buf + dir);
+ if ((extra == 0 && block_id != 1) /* Must be 1 for base data */
+ || (extra == 1 && block_id != 2)) /* Must be 2 for i1pro2 extra data*/
+ return I1PRO_DATA_KEY_CORRUPT;
+
+ nokeys = buf2ushort(buf + dir + 2); /* Bytes in key table */
+ if (nokeys < 300 || nokeys > 512)
+ return I1PRO_DATA_KEY_COUNT;
+
+ nokeys = (nokeys - 4)/6; /* Number of 6 byte entries */
+
+ a1logd(p->log,3,"%d key/values in EEProm table %d\n",nokeys, extra);
+
+ /* We need current and next value to figure data size out */
+ bp = buf + dir + 4;
+ key = buf2ushort(bp);
+ off = buf2int(bp+2);
+ bp += 6;
+ for (i = 0; i < nokeys; i++, bp += 6, key = nkey, off = noff) {
+ i1_dtype type;
+
+ if (i < (nokeys-1)) {
+ nkey = buf2ushort(bp);
+ noff = buf2int(bp+2);
+ }
+ size = noff - off;
+ if (size < 0)
+ size = 0;
+ type = d->det_type(d, key);
+
+ a1logd(p->log,3,"Table entry %d is Key 0x%04x, type %d addr 0x%x, size %d\n",
+ i,key,type,off,size);
+
+ /* Check data is within range */
+ if (off >= len || noff < off || noff > len) {
+ a1logd(p->log,3,"Key 0x%04x offset %d and length %d out of range\n",key,off,noff);
+ return I1PRO_DATA_KEY_MEMRANGE;
+ }
+
+ if (type == i1_dtype_unknown) {
+ if (d->log->debug >= 7) {
+ int i;
+ char oline[100], *bp = oline;
+ bp = oline;
+ a1logd(d->log,7,"Key 0x%04x is unknown type\n",key);
+ for (i = 0; i < size; i++) {
+ if ((i % 16) == 0)
+ bp += sprintf(bp," %04x:",i);
+ bp += sprintf(bp," %02x",buf[off + i]);
+ if ((i+1) >= size || ((i+1) % 16) == 0) {
+ bp += sprintf(bp,"\n");
+ a1logd(p->log,7,oline);
+ bp = oline;
+ }
+ }
+ }
+ if (type == i1_dtype_unknown)
+ continue; /* Ignore it */
+ }
+ if (type == i1_dtype_section) {
+ if ((rv = i1data_add_eosmarker(d, key, off)) != I1PRO_OK) {
+ a1logd(p->log,3,"Key 0x%04x section marker failed with 0x%x\n",key,rv);
+ return rv;
+ }
+ continue;
+ }
+ if (i >= nokeys) {
+ a1logd(p->log,3,"Last key wasn't a section marker!\n");
+ return I1PRO_DATA_KEY_ENDMARK;
+ }
+ if (type == i1_dtype_short) {
+ if ((rv = i1data_unser_shorts(d, key, off, buf + off, size)) != I1PRO_OK) {
+ a1logd(p->log,3,"Key 0x%04x short unserialise failed with 0x%x\n",key,rv);
+ return rv;
+ }
+ } else if (type == i1_dtype_int) {
+ if ((rv = i1data_unser_ints(d, key, off, buf + off, size)) != I1PRO_OK) {
+ a1logd(p->log,3,"Key 0x%04x int unserialise failed with 0x%x\n",key,rv);
+ return rv;
+ }
+ } else if (type == i1_dtype_double) {
+ if ((rv = i1data_unser_doubles(d, key, off, buf + off, size)) != I1PRO_OK) {
+ a1logd(p->log,3,"Key 0x%04x double unserialise failed with 0x%x\n",key,rv);
+ return rv;
+ }
+ } else {
+ a1logd(p->log,3,"Key 0x%04x has type we can't handle!\n",key);
+ }
+ }
+
+ return I1PRO_OK;
+}
+
+/* Compute and set the checksum, then serialise all the keys up */
+/* to the first marker into a buffer, ready for writing back to */
+/* the EEProm. It is an error if this buffer is not located at */
+/* zero in the EEProm */
+static i1pro_code i1data_prep_section1(
+i1data *d,
+unsigned char **buf, /* return allocated buffer */
+unsigned int *len
+) {
+ i1pro *p = d->p;
+ i1proimp *m = d->m;
+ int chsum1, *chsum2;
+ i1keyv *k, *sk, *j;
+ i1pro_code ev = I1PRO_OK;
+
+ a1logd(p->log,5,"i1data_prep_section1 called\n");
+
+ /* Compute the checksum for the first copy of the log data */
+ chsum1 = m->data->checksum(m->data, 0);
+
+ /* Locate and then set the checksum */
+ if ((chsum2 = m->data->get_int(m->data, key_checksum, 0)) == NULL) {
+ a1logd(p->log,2,"i1data_prep_section1 failed to locate checksum\n");
+ return I1PRO_INT_PREP_LOG_DATA;
+ }
+ *chsum2 = chsum1;
+
+ /* Locate the first section marker */
+ for (sk = d->head; sk != NULL; sk = sk->next) {
+ if (sk->type == i1_dtype_section)
+ break;
+ }
+ if (sk == NULL) {
+ a1logd(p->log,2,"i1data_prep_section1 failed to find section marker\n");
+ return I1PRO_INT_PREP_LOG_DATA;
+ }
+
+ /* for each key up to the first section marker */
+ /* check it resides within that section, and doesn't */
+ /* overlap any other key. */
+ for (k = d->head; k != NULL; k = k->next) {
+ if (k->type == i1_dtype_section)
+ break;
+ if (k->addr < 0 || k->addr >= sk->addr || (k->addr + k->size) > sk->addr) {
+ a1logd(p->log,2,"i1data_prep_section1 found key outside section\n");
+ return I1PRO_INT_PREP_LOG_DATA;
+ }
+ for (j = k->next; j != NULL; j = j->next) {
+ if (j->type == i1_dtype_section)
+ break;
+ if ((j->addr >= k->addr && j->addr < (k->addr + k->size))
+ || ((j->addr + j->size) > k->addr && (j->addr + j->size) <= (k->addr + k->size))) {
+ a1logd(p->log,2,"i1data_prep_section1 found key overlap section, 0x%x %d and 0x%x %d\n",
+ k->addr, k->size, j->addr, j->size);
+ return I1PRO_INT_PREP_LOG_DATA;
+ }
+ }
+ }
+
+ /* Allocate the buffer for the data */
+ *len = sk->addr;
+ if ((*buf = (unsigned char *)calloc(sk->addr, sizeof(unsigned char))) == NULL) {
+ a1logw(p->log, "i1data: malloc failed!\n");
+ return I1PRO_INT_MALLOC;
+ }
+
+ /* Serialise it into the buffer */
+ for (k = d->head; k != NULL; k = k->next) {
+ if (k->type == i1_dtype_section)
+ break;
+ else if (k->type == i1_dtype_int) {
+ if ((ev = m->data->ser_ints(m->data, k, *buf, *len)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1data_prep_section1 serializing ints failed\n");
+ return ev;
+ }
+ } else if (k->type == i1_dtype_double) {
+ if ((ev = m->data->ser_doubles(m->data, k, *buf, *len)) != I1PRO_OK) {
+ a1logd(p->log,2,"i1data_prep_section1 serializing doubles failed\n");
+ return ev;
+ }
+ } else {
+ a1logd(p->log,2,"i1data_prep_section1 tried to serialise unknown type\n");
+ return I1PRO_INT_PREP_LOG_DATA;
+ }
+ }
+ a1logd(p->log,5,"a_prep_section1 done\n");
+ return ev;
+}
+
+
+/* Return the data type for the given key identifier */
+static i1_dtype i1data_det_type(i1data *d, i1key key) {
+
+ if (key < 0x100)
+ return i1_dtype_section;
+
+ switch(key) {
+ /* Log keys */
+ case key_meascount:
+ case key_meascount + 1000:
+ return i1_dtype_int;
+ case key_darkreading:
+ case key_darkreading + 1000:
+ return i1_dtype_int;
+ case key_whitereading:
+ case key_whitereading + 1000:
+ return i1_dtype_int;
+ case key_gainmode:
+ case key_gainmode + 1000:
+ return i1_dtype_int;
+ case key_inttime:
+ case key_inttime + 1000:
+ return i1_dtype_double;
+ case key_caldate:
+ case key_caldate + 1000:
+ return i1_dtype_int;
+ case key_calcount:
+ case key_calcount + 1000:
+ return i1_dtype_int;
+ case key_checksum:
+ case key_checksum + 1000:
+ return i1_dtype_int;
+ case key_rpinttime:
+ case key_rpinttime + 1000:
+ return i1_dtype_double;
+ case key_rpcount:
+ case key_rpcount + 1000:
+ return i1_dtype_int;
+ case key_acount:
+ case key_acount + 1000:
+ return i1_dtype_int;
+ case key_lampage:
+ case key_lampage + 1000:
+ return i1_dtype_double;
+
+
+ /* Intstrument calibration keys */
+ case key_ng_lin:
+ return i1_dtype_double;
+ case key_hg_lin:
+ return i1_dtype_double;
+ case key_min_int_time:
+ return i1_dtype_double;
+ case key_max_int_time:
+ return i1_dtype_double;
+ case key_mtx_index:
+ return i1_dtype_int;
+ case key_mtx_nocoef:
+ return i1_dtype_int;
+ case key_mtx_coef:
+ return i1_dtype_double;
+ case key_0bb9:
+ return i1_dtype_int;
+ case key_0bba:
+ return i1_dtype_int;
+ case key_white_ref:
+ return i1_dtype_double;
+ case key_emis_coef:
+ return i1_dtype_double;
+ case key_amb_coef:
+ return i1_dtype_double;
+ case key_0fa0:
+ return i1_dtype_int;
+ case key_0bbf:
+ return i1_dtype_int;
+ case key_cpldrev:
+ return i1_dtype_int;
+ case key_0bc1:
+ return i1_dtype_int;
+ case key_capabilities:
+ return i1_dtype_int;
+ case key_0bc3:
+ return i1_dtype_int;
+ case key_physfilt:
+ return i1_dtype_int;
+ case key_0bc5:
+ return i1_dtype_int;
+ case key_0bc6:
+ return i1_dtype_double;
+ case key_sens_target:
+ return i1_dtype_int;
+ case key_sens_dark:
+ return i1_dtype_int;
+ case key_ng_sens_sat:
+ return i1_dtype_int;
+ case key_hg_sens_sat:
+ return i1_dtype_int;
+ case key_serno:
+ return i1_dtype_int;
+ case key_dom:
+ return i1_dtype_int;
+ case key_hg_factor:
+ return i1_dtype_double;
+ default:
+ return i1_dtype_unknown;
+
+ /* i1pro2 keys */
+ case 0x2ee0:
+ return i1_dtype_unknown; // ~~
+ case 0x2ee1:
+ return i1_dtype_char;
+ case 0x2ee2:
+ return i1_dtype_int;
+ case 0x2ee3:
+ return i1_dtype_int;
+ case 0x2ee4:
+ return i1_dtype_unknown; // ~~
+
+ case 0x2eea:
+ return i1_dtype_int;
+ case 0x2eeb:
+ return i1_dtype_int;
+ case 0x2eec:
+ return i1_dtype_int;
+
+ case 0x2ef4:
+ return i1_dtype_double;
+ case 0x2ef5:
+ return i1_dtype_double;
+ case 0x2ef6:
+ return i1_dtype_double;
+ case 0x2ef9:
+ return i1_dtype_double;
+ case 0x2efa:
+ return i1_dtype_double;
+ case 0x2efe:
+ return i1_dtype_int;
+ case 0x2eff:
+ return i1_dtype_int;
+
+ case 0x2f08:
+ return i1_dtype_double;
+ case 0x2f09:
+ return i1_dtype_double;
+ case 0x2f12:
+ return i1_dtype_double;
+ case 0x2f13:
+ return i1_dtype_double;
+ case 0x2f14:
+ return i1_dtype_double;
+ case 0x2f15:
+ return i1_dtype_double;
+
+ case 0x2f44: /* Wavelength LED reference shape ? */
+ return i1_dtype_double;
+ case 0x2f45:
+ return i1_dtype_int;
+ case 0x2f46:
+ return i1_dtype_double;
+ case 0x2f4e:
+ return i1_dtype_double;
+ case 0x2f4f:
+ return i1_dtype_double;
+ case 0x2f50:
+ return i1_dtype_double;
+ case 0x2f58:
+ return i1_dtype_short; /* Stray light compensation table */
+ case 0x2f59:
+ return i1_dtype_double; /* Stray light scale factor ? */
+ case 0x2f62:
+ return i1_dtype_double;
+ case 0x2f63:
+ return i1_dtype_double;
+ case 0x2f6c:
+ return i1_dtype_double;
+ case 0x2f6d:
+ return i1_dtype_double;
+ case 0x2f6e:
+ return i1_dtype_double;
+ case 0x2f76:
+ return i1_dtype_double;
+ case 0x2f77:
+ return i1_dtype_double;
+
+ case 0x32c8:
+ return i1_dtype_int; // Date
+ case 0x32c9:
+ return i1_dtype_int; // Date
+ case 0x32ca:
+ return i1_dtype_unknown; // ~~
+
+ case 0x36b0:
+ return i1_dtype_int; // Date
+ case 0x36b1:
+ return i1_dtype_int; // Date
+ case 0x36b2:
+ return i1_dtype_unknown; // ~~
+
+ case 0x3a99:
+ return i1_dtype_unknown; // ~~
+ case 0x3a9a:
+ return i1_dtype_unknown; // ~~
+ case 0x3a9b:
+ return i1_dtype_unknown; // ~~
+ case 0x3a9c:
+ return i1_dtype_unknown; // ~~
+ case 0x3a9d:
+ return i1_dtype_unknown; // ~~
+
+ case 0x3e81:
+ return i1_dtype_char; // "X-Rite"
+ case 0x3e82:
+ return i1_dtype_unknown; // ~~
+ case 0x3e8a:
+ return i1_dtype_unknown; // ~~
+
+ case 0x3e94:
+ return i1_dtype_unknown; // ~~
+
+ }
+ return i1_dtype_unknown;
+}
+
+/* Given an index starting at 0, return the matching key code */
+/* for keys that get checksummed. Return 0 if outside range. */
+static i1key i1data_chsum_keys(
+ i1data *d,
+ int index
+) {
+ switch(index) {
+ case 0:
+ return key_meascount;
+ case 1:
+ return key_darkreading;
+ case 2:
+ return key_whitereading;
+ case 3:
+ return key_gainmode;
+ case 4:
+ return key_inttime;
+ case 5:
+ return key_caldate;
+ case 6:
+ return key_calcount;
+ case 7:
+ return key_rpinttime;
+ case 8:
+ return key_rpcount;
+ case 9:
+ return key_acount;
+ case 10:
+ return key_lampage;
+ }
+ return 0;
+}
+
+/* Compute a checksum. */
+static int i1data_checksum(
+ i1data *d,
+ i1key keyoffset /* Offset to apply to keys */
+) {
+ int i, n, j;
+ int chsum = 0;
+
+ for (i = 0; ; i++) {
+ i1key key;
+ i1keyv *k;
+
+ if ((key = d->chsum_keys(d, i)) == 0)
+ break; /* we're done */
+
+ key += keyoffset;
+
+ if ((k = d->find_key(d, key)) == NULL)
+ continue; /* Hmm */
+
+ if (k->type == i1_dtype_int) {
+ for (j = 0; j < k->count; j++)
+ chsum += ((int *)k->data)[j];
+ } else if (k->type == i1_dtype_double) {
+ for (j = 0; j < k->count; j++)
+ chsum += doubletoIEEE754(((double *)k->data)[j]);
+ }
+ }
+
+ return chsum;
+}
+
+/* Destroy ourselves */
+static void i1data_del(i1data *d) {
+ i1keyv *k, *nk;
+
+ del_a1log(d->log); /* Unref it */
+
+ /* Free all the keys and their data */
+ for (k = d->head; k != NULL; k = nk) {
+ nk = k->next;
+ if (k->data != NULL)
+ free(k->data);
+ free(k);
+ }
+ free(d);
+}
+
+/* Constructor for i1data */
+i1data *new_i1data(i1proimp *m) {
+ i1data *d;
+ if ((d = (i1data *)calloc(1, sizeof(i1data))) == NULL) {
+ a1loge(m->p->log, 1, "new_i1data: malloc failed!\n");
+ return NULL;
+ }
+
+ d->p = m->p;
+ d->m = m;
+
+ d->log = new_a1log_d(m->p->log); /* Take reference */
+
+ d->find_key = i1data_find_key;
+ d->make_key = i1data_make_key;
+ d->get_type = i1data_get_type;
+ d->get_count = i1data_get_count;
+ d->get_shorts = i1data_get_shorts;
+ d->get_ints = i1data_get_ints;
+ d->get_doubles = i1data_get_doubles;
+ d->get_int = i1data_get_int;
+ d->get_double = i1data_get_double;
+ d->unser_ints = i1data_unser_ints;
+ d->unser_doubles = i1data_unser_doubles;
+ d->ser_ints = i1data_ser_ints;
+ d->ser_doubles = i1data_ser_doubles;
+ d->parse_eeprom = i1data_parse_eeprom;
+ d->prep_section1 = i1data_prep_section1;
+ d->add_ints = i1data_add_ints;
+ d->add_doubles = i1data_add_doubles;
+ d->del = i1data_del;
+
+ d->det_type = i1data_det_type;
+ d->chsum_keys = i1data_chsum_keys;
+ d->checksum = i1data_checksum;
+
+ return d;
+}
+
+/* ----------------------------------------------------------------- */