Ejemplo n.º 1
0
int
datCcopy(const HDSLoc *locator1, const HDSLoc *locator2, const char *name,
         HDSLoc **locator3, int *status ) {
  char type_str[DAT__SZTYP+1];
  hdsdim hdims[DAT__MXDIM];
  int ndims;

  if (*status != SAI__OK) return *status;

  /* Validate input locators. */
  dat1ValidateLocator( "datCcopy", 1, locator1, 1, status );
  dat1ValidateLocator( "datCcopy", 1, locator2, 0, status );

  if (dat1IsStructure(locator1, status)) {

    /* need the type and dimensionality of the structure to create
       in new location */
    datType( locator1, type_str, status );
    datShape( locator1, DAT__MXDIM, hdims, &ndims, status );

    *locator3 = dat1New( locator2, 0, name, type_str, ndims, hdims, status );

  } else {
    hdsbool_t state = 0;
    /* We only copy if the primitive object is defined */
    datState( locator1, &state, status );
    if ( state ) {
      datCopy( locator1, locator2, name, status );
    } else {
      /* Undefined so just make something of the right shape and type */
      datType( locator1, type_str, status );
      datShape( locator1, DAT__MXDIM, hdims, &ndims, status );
      datNew( locator2, name, type_str, ndims, hdims, status );
    }

    /* and get a locator to the copied entity */
    datFind( locator2, name, locator3, status );

  }

  return *status;
}
Ejemplo n.º 2
0
static PyObject*
pydat_type(HDSObject *self)
{
    // Recover C-pointer passed via Python
    HDSLoc* loc = HDS_retrieve_locator(self);

    char typ_str[DAT__SZTYP+1];
    int status = SAI__OK;
    errBegin(&status);
    datType(loc, typ_str, &status);
    if (raiseHDSException(&status)) return NULL;
    return Py_BuildValue("s", typ_str);
};
Ejemplo n.º 3
0
IDL_VPTR hds2idl( int argc, IDL_VPTR argv[] ) {
/*
** Declare variables
*/
IDL_VPTR hds_name;       /* IDL_VPTR to name of the HDS object to be read */
IDL_VPTR var;            /* Variable pointer to IDL object */
IDL_VARIABLE temp;       /* Temporary storage for primitive scalar variable */
IDL_StructDefPtr sdef;   /* Structure definition of sub-structure */
IDL_STRING *objname;     /* Pointer to object name as IDL string */
HDSLoc *objloc = NULL;   /* Locator of file */

int status;             /* Starlink status */

char type[DAT__SZTYP+1];/* HDS type of component */
UCHAR idltype;          /* IDl type of component */
int ndims;              /* Number of dimensions of object */
int dims[DAT__MXDIM];   /* Dimensions of object HDS style */
IDL_LONG idldims[DAT__MXDIM];/* Dimensions of object IDL style */
int i;                  /* loop index */
int fstat;              /* Final status (before emsEload) */
int isstruct;           /* Whether object is structure */
void *tdata;            /* Pointer to data area of IDL variable or array */

char param[EMS__SZPAR+1]; /* Error message parameter name */
int parlen;             /* Length of error message parameter name */
char opstr[EMS__SZMSG+1]; /* Error message */
int oplen;              /* Length of error message */

IDL_LONG one[IDL_MAX_ARRAY_DIM]={1};

/* Start Error context */
   status = SAI__OK;
   emsMark();

/* Check that the correct number of arguments were passed in */
   if(argc != 1) {

   /* Print an error message and return */
      status = SAI__ERROR;
      emsRep( " ", "hds2idl: Incorrect number of arguments", &status );

   } else {
   /* Extract the arguments to comprehensible names */
      hds_name = argv[0];
      objname = &hds_name->value.str;

   /* Open the HDS object */
      getcomp( IDL_STRING_STR(objname), "READ", &objloc, &status );

   /* Check for structure or primitive */
      datStruc( objloc, &isstruct, &status );
      if (status == SAI__OK) {
         if ( isstruct ) {
         /* Create a structure */
            sdef = idlstructdef( objloc, &status );

         /* Create a temporary variable */
            if ( status == SAI__OK ) {
               (void *)IDL_MakeTempStruct( sdef, 1, one, &var, TRUE );
               idlstructfill( objloc, var->value.s, &status );
            }

         } else {
         /* Object is primitive */
            datType( objloc, type, &status );
            idltype = getidltype( type );
            datShape( objloc, DAT__MXDIM, dims, &ndims, &status );
            if ( status == SAI__OK ) {
               if (ndims) {
               /* Get dimensions IDL style */
                  for (i=0;i<ndims;i++) idldims[i] = (IDL_LONG)dims[i];
               /* Object is primitive array */
                  tdata = IDL_MakeTempArray( (int)idltype, ndims, idldims,
                    IDL_BARR_INI_ZERO , &var );

               } else {
               /* Object is primitive scalar */
                  var = &temp;
                  var->type = idltype;
                  var->flags = 0;
                  tdata = &var->value;
               }

               idlprimfill( objloc, var, tdata, &status );
            }

         }

      /* Annul the object (and close the file) */
         datAnnul( &objloc, &status );
      }
   }

   if ( status != SAI__OK ) {
   /*  Report any error messages             */
   /*  Adding Starlink-style !! and ! prefix */
      fstat = status;
      while ( status != SAI__OK ) {
         emsEload(
            param, &parlen, opstr, &oplen, &status );
         if ( status != SAI__OK )
            IDL_Message( IDL_M_NAMED_GENERIC, IDL_MSG_INFO, opstr );
      }

   /*  Set to return undefined variable */
      var = IDL_Gettmp();

   /*  and close error context */
      emsRlse();
   }

/*  That's it, return to the calling routine */
   return var;
}
Ejemplo n.º 4
0
void idlprimfill( HDSLoc *cloc, IDL_VPTR datav, void *datptr, int *status ) {

int j;                  /* loop counters */
UCHAR idltype;            /* The IDL type */
char type[DAT__SZTYP+1];  /* Type in which to to map HDS data */
int bpix;                 /* Number of bytes/value */
int defined;              /* If HDS value defined */
void *cpntr;              /* True C pointer to mapped data */
size_t nels;              /* Number of mapped elements */
int nels_i;
size_t nbytes;            /* Number of bytes in array */
int flen;                 /* length of HDS strings */
int clen;                 /* length of corresponding C string */
char *chars;              /* pointer to imported characters */
IDL_STRING *strings;      /* pointer to array of string structures */
IDL_VPTR chptr;           /* Scratch variable pointer */

if ( *status != SAI__OK ) return;

/* check type compatibility */
/* Get the number of bytes per element */
/* and the HDS type in which to  map the data */
   idltype = datav->type;

   switch (idltype) {
   case IDL_TYP_FLOAT:
      strcpy( type, "_REAL" );
      bpix = 4;
      break;
   case IDL_TYP_LONG:
      strcpy( type, "_INTEGER" );
      bpix = 4;
      break;
   case IDL_TYP_INT:
      strcpy( type, "_WORD" );
      bpix = 2;
      break;
   case IDL_TYP_DOUBLE:
      strcpy( type, "_DOUBLE" );
      bpix = 8;
      break;
   case IDL_TYP_BYTE:
      strcpy( type, "_UBYTE" );
      bpix = 1;
      break;
   case IDL_TYP_STRING:
      datType( cloc, type, status);
      bpix = 1;
      break;
   default:
/* flag no data to copy */
      bpix = 0;
      *status = SAI__ERROR;
      emsSeti( "TYPE", idltype );
      emsRep( " ", "Illegal IDL type ^TYPE", status );
      break;
   } /* end of case */

   if ( (*status == SAI__OK ) && bpix ) {
/* Map the data as if a vector - provided it is defined */
      datState( cloc, &defined, status );
      if ( defined ) {
         datMapV( cloc, type, "READ", &cpntr, &nels, status );
         if ( *status != SAI__OK ) {
            emsRep(" ", "Failed to map HDS component", status );
         } else {
            if ( idltype == IDL_TYP_STRING ) {
               flen = atoi( type + 6 );
               clen = flen + 1;

/* Import the Fortran strings to C */
               nels_i = (int)nels;
               chars = IDL_GetScratch( &chptr, nels_i, clen );
               cnfImprta( cpntr, flen, chars, clen, 1, &nels_i );

/* set strings to be a pointer to the IDL_STRING structure(s) */
               strings = (IDL_STRING *)datptr;

/* store the imported strings into the STRING structures */
               for ( j=0; j<nels; j++ )
                  IDL_StrStore( strings+j, &chars[j*clen] );
               IDL_Deltmp( chptr );

            } else {
/* Type other than string */
               if ( datav->flags & IDL_V_ARR ) {
/* Number Array */
/* copy the data to the array */
                  nbytes = bpix * nels;
                  memcpy( datptr, cpntr, nbytes );
               } else {
/* Number Scalar */
                  switch (idltype) {
                  case IDL_TYP_FLOAT:
                     ((IDL_ALLTYPES *)datptr)->f = *(float *)cpntr;
                     break;
                  case IDL_TYP_LONG:
                     ((IDL_ALLTYPES *)datptr)->l = *(int *)cpntr;
                     break;
                  case IDL_TYP_INT:
                     ((IDL_ALLTYPES *)datptr)->i = *(short *)cpntr;
                     break;
                  case IDL_TYP_DOUBLE:
                     ((IDL_ALLTYPES *)datptr)->d = *(double *)cpntr;
                     break;
                  case IDL_TYP_BYTE:
                     ((IDL_ALLTYPES *)datptr)->c = *(UCHAR *)cpntr;
                     break;
                  } /* end of case */
               } /* end of if array */
            } /* end if string */
            datUnmap( cloc, status );
         } /* end of mapped data */
      } /* end of if defined */
   } /* end of bpix non-zero */

   return;

}
Ejemplo n.º 5
0
static PyObject*
pydat_get(HDSObject *self)
{
    // Recover C-pointer passed via Python
    HDSLoc* loc = HDS_retrieve_locator(self);

    // guard against structures
    int state, status = SAI__OK;
    errBegin(&status);
    datStruc(loc, &state, &status);
    if (raiseHDSException(&status)) return NULL;
    if(state) {
        PyErr_SetString(PyExc_IOError, "dat_get error: cannot use on structures");
        return NULL;
    }

    // get type
    char typ_str[DAT__SZTYP+1];
    datType(loc, typ_str, &status);

    // get shape
    const int NDIMX=7;
    int ndim;
    hdsdim tdim[NDIMX];
    datShape(loc, NDIMX, tdim, &ndim, &status);
    if (raiseHDSException(&status)) return NULL;

    PyArrayObject* arr = NULL;

    // Either return values as a single scalar or a numpy array

    // Reverse order of dimensions
    npy_intp rdim[NDIMX];
    int i;
    for(i=0; i<ndim; i++) rdim[i] = tdim[ndim-i-1];

    if(strcmp(typ_str, "_INTEGER") == 0 || strcmp(typ_str, "_LOGICAL") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_INT);
    } else if(strcmp(typ_str, "_REAL") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_FLOAT);
    } else if(strcmp(typ_str, "_DOUBLE") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_DOUBLE);
    } else if(strncmp(typ_str, "_CHAR", 5) == 0) {

        // work out the number of bytes
        size_t nbytes;
        datLen(loc, &nbytes, &status);
        if (status != SAI__OK) goto fail;

        int ncdim = 1+ndim;
        int cdim[ncdim];
        cdim[0] = nbytes+1;
        for(i=0; i<ndim; i++) cdim[i+1] = rdim[i];

        PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_STRING);
        descr->elsize = nbytes;
        arr = (PyArrayObject*) PyArray_NewFromDescr(&PyArray_Type, descr, ndim, rdim,
                NULL, NULL, 0, NULL);

    } else if(strcmp(typ_str, "_WORD") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_SHORT);
    } else if(strcmp(typ_str, "_UWORD") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_USHORT);
    } else if(strcmp(typ_str, "_BYTE") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_BYTE);
    } else if(strcmp(typ_str, "_UBYTE") == 0) {
        arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_UBYTE);
    } else {
        PyErr_SetString(PyExc_IOError, "dat_get: encountered an unimplemented type");
        return NULL;
    }
    if(arr == NULL) goto fail;
    datGet(loc, typ_str, ndim, tdim, arr->data, &status);
    if(status != SAI__OK) goto fail;
    return PyArray_Return(arr);

fail:
    raiseHDSException(&status);
    Py_XDECREF(arr);
    return NULL;

};