int linfree(struct linprm *lin)
{
if (lin == 0x0) return LINERR_NULL_POINTER;
if (lin->flag != -1) {
/* Optionally allocated by linini() for given parameters. */
if (lin->m_flag == LINSET) {
if (lin->crpix == lin->m_crpix) lin->crpix = 0x0;
if (lin->pc == lin->m_pc) lin->pc = 0x0;
if (lin->cdelt == lin->m_cdelt) lin->cdelt = 0x0;
if (lin->dispre == lin->m_dispre) lin->dispre = 0x0;
if (lin->disseq == lin->m_disseq) lin->disseq = 0x0;
if (lin->m_crpix) free(lin->m_crpix);
if (lin->m_pc) free(lin->m_pc);
if (lin->m_cdelt) free(lin->m_cdelt);
if (lin->m_dispre) {
disfree(lin->m_dispre);
free(lin->m_dispre);
}
if (lin->m_disseq) {
disfree(lin->m_disseq);
free(lin->m_disseq);
}
}
/* Allocated unconditionally by linset(). */
if (lin->piximg) free(lin->piximg);
if (lin->imgpix) free(lin->imgpix);
if (lin->tmpcrd) free(lin->tmpcrd);
if (lin->err) free(lin->err);
}
lin->m_flag = 0;
lin->m_naxis = 0;
lin->m_crpix = 0x0;
lin->m_pc = 0x0;
lin->m_cdelt = 0x0;
lin->m_dispre = 0x0;
lin->m_disseq = 0x0;
lin->piximg = 0x0;
lin->imgpix = 0x0;
lin->i_naxis = 0;
lin->tmpcrd = 0x0;
lin->err = 0x0;
lin->flag = 0;
return 0;
}
int lindist(int sequence, struct linprm *lin, struct disprm *dis, int ndpmax)
{
static const char *function = "lindist";
int status;
struct wcserr **err;
if (lin == 0x0) return LINERR_NULL_POINTER;
err = &(lin->err);
if (sequence == 1) {
if (lin->m_dispre) {
disfree(lin->m_dispre);
free(lin->m_dispre);
}
lin->dispre = dis;
lin->m_flag = LINSET;
lin->m_dispre = dis;
} else if (sequence == 2) {
if (lin->m_disseq) {
disfree(lin->m_disseq);
free(lin->m_disseq);
}
lin->disseq = dis;
lin->m_flag = LINSET;
lin->m_disseq = dis;
} else {
return wcserr_set(WCSERR_SET(LINERR_DISTORT_INIT),
"Invalid sequence (%d)", sequence);
}
if (dis) {
if ((status = disinit(1, lin->naxis, dis, ndpmax))) {
return wcserr_set(LIN_ERRMSG(lin_diserr[status]));
}
}
return 0;
}
int lincpy(int alloc, const struct linprm *linsrc, struct linprm *lindst)
{
static const char *function = "lincpy";
int i, j, naxis, status;
const double *srcp;
double *dstp;
struct wcserr **err;
if (linsrc == 0x0) return LINERR_NULL_POINTER;
if (lindst == 0x0) return LINERR_NULL_POINTER;
err = &(lindst->err);
naxis = linsrc->naxis;
if (naxis < 1) {
return wcserr_set(WCSERR_SET(LINERR_MEMORY),
"naxis must be positive (got %d)", naxis);
}
if ((status = lininit(alloc, naxis, lindst, 0))) {
return status;
}
srcp = linsrc->crpix;
dstp = lindst->crpix;
for (j = 0; j < naxis; j++) {
*(dstp++) = *(srcp++);
}
srcp = linsrc->pc;
dstp = lindst->pc;
for (i = 0; i < naxis; i++) {
for (j = 0; j < naxis; j++) {
*(dstp++) = *(srcp++);
}
}
srcp = linsrc->cdelt;
dstp = lindst->cdelt;
for (i = 0; i < naxis; i++) {
*(dstp++) = *(srcp++);
}
if (linsrc->dispre) {
if (!lindst->dispre) {
if ((lindst->dispre = calloc(1, sizeof(struct disprm))) == 0x0) {
return wcserr_set(LIN_ERRMSG(LINERR_MEMORY));
}
lindst->m_dispre = lindst->dispre;
}
if ((status = discpy(alloc, linsrc->dispre, lindst->dispre))) {
status = wcserr_set(LIN_ERRMSG(lin_diserr[status]));
goto cleanup;
}
}
if (linsrc->disseq) {
if (!lindst->disseq) {
if ((lindst->disseq = calloc(1, sizeof(struct disprm))) == 0x0) {
return wcserr_set(LIN_ERRMSG(LINERR_MEMORY));
}
lindst->m_disseq = lindst->disseq;
}
if ((status = discpy(alloc, linsrc->disseq, lindst->disseq))) {
status = wcserr_set(LIN_ERRMSG(lin_diserr[status]));
goto cleanup;
}
}
cleanup:
if (status) {
if (lindst->m_dispre) {
disfree(lindst->m_dispre);
free(lindst->m_dispre);
lindst->m_dispre = 0x0;
lindst->dispre = 0x0;
}
if (lindst->m_disseq) {
disfree(lindst->m_disseq);
free(lindst->m_disseq);
lindst->m_disseq = 0x0;
lindst->disseq = 0x0;
}
}
return status;
}
