コード例 #1
0
ファイル: check.c プロジェクト: gregus/GPU-SExtractor
/*
initialize check-image.
*/
checkstruct	*initcheck(char *filename, checkenum check_type, int next)

  {
   catstruct	*fitscat;
   checkstruct	*check;

  QCALLOC(check, checkstruct, 1);

  strcpy(check->filename, filename);
  check->type = check_type;

  if (next>1)
/*-- Create a "pure" primary HDU */
    {
    fitscat = new_cat(1);
    init_cat(fitscat);
    strcpy(fitscat->filename, filename);
    fitsadd(fitscat->tab->headbuf, "NEXTEND ", "Number of extensions");
    fitswrite(fitscat->tab->headbuf, "NEXTEND ", &next, H_INT, T_LONG);
    if (open_cat(fitscat, WRITE_ONLY) != RETURN_OK)
      error(EXIT_FAILURE,"*Error*: cannot open for writing ", filename);
    save_tab(fitscat, fitscat->tab);
    check->file = fitscat->file;
    fitscat->file = NULL;
    free_cat(&fitscat, 1);
    }
  else
    if (!(check->file = fopen(check->filename, "wb")))
      error(EXIT_FAILURE, "*Error*: Cannot open for output ", check->filename);

  return check;
  }
コード例 #2
0
ファイル: fitswrite.c プロジェクト: gregus/GPU-SExtractor
/****** save_cat **************************************************************
PROTO	void save_cat(catstruct *cat, char *filename)
PURPOSE	Save a FITS catalog with name filename.
INPUT	catalog structure,
	filename.
OUTPUT	-.
NOTES	Any preexisting file with name filename is overwritten.
AUTHOR	E. Bertin (IAP)
VERSION	09/09/2003
 ***/
void	save_cat(catstruct *cat, char *filename)

{
	tabstruct	*tab;
	int		i;

	strcpy(cat->filename, filename);
	if (open_cat(cat, WRITE_ONLY) != RETURN_OK)
		error(EXIT_FAILURE, "*Error*: cannot open for writing ", filename);

	tab = cat->tab;
	/*Go through each segment in the right order to save data*/
	for (i=0; i<cat->ntab; i++)
	{
		/*-- Make sure that the tab header is primary or extension! */
		if (i)
			ext_head(tab);
		else
			prim_head(tab);
		save_tab(cat, tab);
		while (!((tab=tab->nexttab)->nseg));
	}

	if (close_cat(cat) != RETURN_OK)
		error(EXIT_FAILURE, "*Error*: Problem while closing", cat->filename);

	return;
}
コード例 #3
0
ファイル: fitsread.c プロジェクト: Starlink/starextract
/****** read_cats **************************************************************
PROTO	read_cats(char **filenames, int ncat)
PURPOSE	``Read'' several FITS catalogs.
INPUT	A pointer to pointers of char,
	The number of catalogs.
OUTPUT	catstruct pointer.
NOTES	-.
AUTHOR	E. Bertin (IAP & Leiden observatory)
VERSION	25/04/97
 ***/
catstruct	*read_cats(char **filenames, int ncat)

  {
   catstruct	*cat, *ccat;
   int		i;

  if (!(cat = new_cat(ncat)))
    error (EXIT_FAILURE, "Not enough memory to read ", "catalogs");

  for (i=ncat, ccat = cat; i--; ccat++, filenames++)
    {
    strcpy(ccat->filename, *filenames);
    if (open_cat(ccat, READ_ONLY) != RETURN_OK)
      error (EXIT_FAILURE, "Cannot open ", *filenames);
    if (map_cat(ccat) != RETURN_OK)
      error (EXIT_FAILURE, "Cannot map ", *filenames);
    close_cat(ccat);
    }

  return cat;
  }
コード例 #4
0
ファイル: fitsread.c プロジェクト: Starlink/starextract
/****** read_cat ***************************************************************
PROTO	catstruct read_cat(char *filename)
PURPOSE	``Read'' a FITS catalog with name filename.
INPUT	Filename,
OUTPUT	catstruct pointer.
NOTES	Returns NULL if no file with name \<filename\> is found.
AUTHOR	E. Bertin (IAP & Leiden observatory)
VERSION	07/05/2002
 ***/
catstruct	*read_cat(char *filename)

  {
   catstruct *cat;

  if (!(cat = new_cat(1)))
    error (EXIT_FAILURE, "Not enough memory to read ", filename);

  strcpy(cat->filename, filename);
  if (open_cat(cat, READ_ONLY) != RETURN_OK)
    {
    free_cat(&cat, 1);
    return NULL;
    }

  if (map_cat(cat) != RETURN_OK)
    {
    free_cat(&cat, 1);
    return NULL;
    }

  return cat;
  }
コード例 #5
0
ファイル: check.c プロジェクト: RFonteyne/psfex
/****** check_write ********************************************************
PROTO	void	check_write(fieldstruct *field, char *checkname,
		checkenum checktype, int ext, int next, int cubeflag)
PURPOSE	Write a FITS image for check.
INPUT	Pointer to the field,
	Pointer to the set,
	Check-image filename,
	Check-image type,
	Extension number,
	Number of extensions,
	Datacube flag.
OUTPUT  -.
NOTES   Check-image is written as a datacube if cubeflag!=0.
AUTHOR  E. Bertin (IAP)
VERSION 21/09/2015
 ***/
void	check_write(fieldstruct *field, setstruct *set, char *checkname,
		checkenum checktype, int ext, int next, int cubeflag)
  {
   psfstruct		*psf;
   catstruct		*cat;
   tabstruct		*tab;
   samplestruct		**gridsample,
			*sample,*osample;
   char			filename[MAXCHAR], str[82],
			*head, *pstr,*pstr2;
   static double	dpos[POLY_MAXDIM], *dpost;
   double		dstep,dstart, dval1,dval2, scalefac, dstepx,dstepy;
   float		*pix,*pix0, *vig,*vig0, *fpix,*fpixsym,
			val;
   int			i,g,j,l,x,y, w,h,n, npc,nt, nw,nh,np, npos,npos2,
			step,step2, ipos, inpos, ival1,ival2, npix;

/* Create the new cat (well it is not a "cat", but simply a FITS table */
  if (!ext)
    {
    cat = new_cat(1);
    init_cat(cat);
    strcpy(cat->filename, checkname);
    if (!(pstr = strrchr(cat->filename, '.')))
      pstr = cat->filename+strlen(cat->filename);
    strcpy(filename, field->rcatname);
    if (!(pstr2 = strrchr(filename, '.')))
      pstr2 = filename+strlen(filename);
    *pstr2 = '\0';
    sprintf(pstr, "_%s.fits", filename);
    if (open_cat(cat, WRITE_ONLY) != RETURN_OK)
      error(EXIT_FAILURE, "*Error*: cannot open for writing ", cat->filename);
    if (next>1)
      {
      addkeywordto_head(cat->tab, "NEXTEND ", "Number of extensions");
      fitswrite(cat->tab->headbuf, "NEXTEND", &next, H_INT, T_LONG);
      save_tab(cat, cat->tab);
      }
    field->ccat[checktype] = cat;
    }
  else
    cat = field->ccat[checktype];

  sprintf(str, "chip%02d", ext+1);

  psf = field->psf[ext];
  tab = new_tab(str);
  head = tab->headbuf;
  tab->bitpix =  BP_FLOAT;
  tab->bytepix = t_size[T_FLOAT];

  switch(checktype)
    {
    case PSF_BASIS:
/*----  View basis vectors as small vignets */
      if (cubeflag)
        {
        tab->naxis = 3;
        QREALLOC(tab->naxisn, int, tab->naxis);
        tab->naxisn[0] = psf->size[0];
        tab->naxisn[1] = psf->size[1];
        tab->naxisn[2] = psf->nbasis;
        npix = tab->naxisn[0]*tab->naxisn[1]*tab->naxisn[2];
        tab->tabsize = tab->bytepix*npix;
        QCALLOC(pix0, float, tab->tabsize);
        tab->bodybuf = (char *)pix0; 
        pix = pix0;
        fpix = psf->basis;
        for (i=npix; i--;)
          *(pix++) = *(fpix++);
        }
      else
        {
        nw = (int)sqrt((double)psf->nbasis);
        nw = ((nw-1)/10+1)*10;
        nh = (psf->nbasis-1)/nw + 1;
        w = psf->size[0];
        h = psf->dim>1? psf->size[1] : 1;
        tab->naxisn[0] = nw*w;
        tab->naxisn[1] = nh*h;
        step = (nw-1)*w;
        tab->tabsize = tab->bytepix*tab->naxisn[0]*tab->naxisn[1];
        QCALLOC(pix0, float, tab->tabsize);
        tab->bodybuf = (char *)pix0; 
        fpix = psf->basis;
        for (n=0; n<psf->nbasis; n++)
          {
          pix = pix0 + ((n%nw) + (n/nw)*nw*h)*w;
          for (y=h; y--; pix += step)
            for (x=w; x--;)
              *(pix++) = *(fpix++);
          }
        }
      break;
    case PSF_CHI:
/*---- sqrt(chi2) map in PSF pixel-space 
      nw = 1;
      nh = 1;
      w = psf->size[0];
      h = psf->size[1];
      tab->naxisn[0] = nw*w;
      tab->naxisn[1] = nh*h;
      tab->tabsize = tab->bytepix*tab->naxisn[0]*tab->naxisn[1];
      QCALLOC(pix0, float, tab->tabsize);
      tab->bodybuf = (char *)pix0; 
      pix = pix0;
      fpix = psf->resi;
      for (i=w*h; i--;)
        *(pix++) = *(fpix++);
      break;
*/
      if (cubeflag)
        {
        tab->naxis = 3;
        QREALLOC(tab->naxisn, int, tab->naxis);
        tab->naxisn[0] = set->vigsize[0];
        tab->naxisn[1] = set->vigsize[1];
        tab->naxisn[2] = set->ngood? set->ngood : 1;
        npix = tab->naxisn[0]*tab->naxisn[1];
        tab->tabsize = tab->bytepix*npix*tab->naxisn[2];
        QCALLOC(pix0, float, tab->tabsize);
        tab->bodybuf = (char *)pix0; 
        pix = pix0;
        sample = set->sample;
        for (n=set->nsample; n--; sample++)
          {
          if (sample->badflag)
            continue;
          fpix = sample->vigchi;
          for (i=npix; i--;)
            *(pix++) = *(fpix++);
          }
        }
      else
        {
コード例 #6
0
ファイル: fitswrite.c プロジェクト: gregus/GPU-SExtractor
/****** save_tab **************************************************************
PROTO	void save_tab(catstruct *cat, tabstruct *tab)
PURPOSE	Save a FITS table.
INPUT	pointer to the catalog structure,
	pointer to the table structure.
OUTPUT	-.
NOTES	-.
AUTHOR	E. Bertin (IAP & Leiden observatory)
VERSION	09/09/2003
 ***/
void	save_tab(catstruct *cat, tabstruct *tab)

{
	catstruct	*tabcat;
	keystruct	*key;
	tabstruct	*keytab;
	KINGSIZE_T	tabsize;
	KINGLONG	size;
	int		b,j,k,o, nbytes,nkey,nobj,spoonful,
	tabflag, larrayin,larrayout;
	char		*buf, *inbuf, *outbuf, *fptr,*ptr;
	int		esize;

	/*  Make the table parameters reflect its content*/
	update_tab(tab);
	/*  The header itself*/
	tabflag = save_head(cat, tab)==RETURN_OK?1:0;
	/*  Allocate memory for the output buffer */
	tabsize = 0;
	tabcat = NULL;	/* to satisfy gcc -Wall */
	inbuf = NULL;		/* to satisfy gcc -Wall */
	if (tabflag)
	{
		/*-- If segment is a binary table, save it row by row */
		QMALLOC(outbuf, char, (larrayout = tab->naxisn[0]));
		nkey = tab->nkey;
		tabsize = larrayin = 0;
		for (j=tab->nseg; j--;)
		{
			update_tab(tab);
			/*---- Scan keys to find the reference tab and other things*/
			keytab = NULL;
			key = tab->key;
			for (k=nkey; k--; key = key->nextkey)
				if (!key->ptr)
				{
					keytab = key->tab;
					tabcat = keytab->cat;
				}
			/*---- If table contains some keys with no ptrs, we have to access a file */
			if (keytab)
			{
				QMALLOC(inbuf, char, (larrayin = keytab->naxisn[0]));
				if (open_cat(tabcat, READ_ONLY) != RETURN_OK)
					error(EXIT_FAILURE, "*Error*: Cannot access ", tabcat->filename);
				QFSEEK(tabcat->file, keytab->bodypos, SEEK_SET, tabcat->filename);
			}
			nobj = tab->naxisn[1];
			for (o=0; o<nobj; o++)
			{
				if (keytab)
					QFREAD(inbuf, larrayin, tabcat->file, tabcat->filename);
				fptr = outbuf;
				for (k=nkey; k--; key = key->nextkey)
				{
					nbytes = key->nbytes;
					ptr = key->ptr? (char *)key->ptr+nbytes*o:inbuf+key->pos;
					for (b=nbytes; b--;)
						*(fptr++) = *(ptr++);
					if (bswapflag)
						if (key->ptr)
						{
							esize = t_size[key->ttype];
							swapbytes(fptr-nbytes, esize, nbytes/esize);
						}
				}
				QFWRITE(outbuf, larrayout, cat->file, cat->filename);
			}
			if (keytab)
			{
				free(inbuf);
				if (close_cat(tabcat) != RETURN_OK)
					error(EXIT_FAILURE, "*Error*: Problem while closing",
							tabcat->filename);
			}
			tabsize += tab->tabsize;
			tab = tab->nexttab;
		}
		free(outbuf);
	}
	else
	{