Пример #1
0
IDL_VPTR IDLStruct::vget(const char *name)
{

  IDL_VPTR tmp;
  UCHAR *p;
  char message[80];
  static int tag_index;

  // Does this tag exist?  This is the bottleneck, by far
  // Better for the user to find the index ahead of time
  // Slightly faster than doing the ful getRefFromIDLStrucf thing

  indexIter = tagIndexHash.find(name);
  if (indexIter == tagIndexHash.end()) tagMessage(name);
  tag_index = indexIter->second;

  // point at the data
  p = ( idlStruct->value.s.arr->data + tag_offsets[tag_index] );


  // for arrays. Problem is we still have to case the result
  if (tag_desc[tag_index]->flags & IDL_V_ARR)
    {
      // should copy the desc pointer efficiency
      tmp = IDL_ImportArray(tag_desc[tag_index]->value.arr->n_dim,
			    tag_desc[tag_index]->value.arr->dim,
			    tag_desc[tag_index]->type,
			    p,
			    NULL,NULL);
    }
  else // scalars: what if we want to modify the value? Should we just import 
    //as array anyway?  But how if the .arr is not set?
    {

      // This could be an issue
      tmp = IDL_Gettmp();

      tmp->type = tagDescHash[name]->type;
      switch (tagDescHash[name]->type) {
      case IDL_TYP_BYTE:    tmp->value.c =    *(UCHAR *)p;       break;
      case IDL_TYP_INT:     tmp->value.i =    *(short *)p;       break;
      case IDL_TYP_UINT:    tmp->value.ui =   *(IDL_UINT *)p;    break;
      case IDL_TYP_LONG:    tmp->value.l =    *(IDL_LONG *)p;    break;
      case IDL_TYP_ULONG:   tmp->value.ul =   *(IDL_ULONG *)p;   break;
      case IDL_TYP_LONG64:  tmp->value.l64 =  *(IDL_LONG64 *)p;  break;
      case IDL_TYP_ULONG64: tmp->value.ul64 = *(IDL_ULONG64 *)p; break;
      case IDL_TYP_FLOAT:   tmp->value.f =    *(float *)p;       break;
	//case IDL_TYP_FLOAT: IDL_StoreScalar(&tmp, IDL_TYP_FLOAT
      case IDL_TYP_DOUBLE:  tmp->value.d =    *(double *)p;      break;
      case IDL_TYP_UNDEF: IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_LONGJMP,
				      "TYPE is undefined");
      default: IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_LONGJMP,
				      "Cannot work with type");
      }

    }

  return(tmp);

}
Пример #2
0
IDL_VPTR IDL_CDECL idl_bam_cxc_get_data(int argc, IDL_VPTR argv[]) {
	QSharedMemory shared_memory("photo");

	//QTextStream(stdout) << shared_memory.nativeKey() << endl;

	if (!shared_memory.attach(QSharedMemory::ReadOnly)) {
		IDL_MessageFromBlock(bam_cxc_msg_block, BAM_CXC_ERROR, IDL_MSG_LONGJMP, "Could not attach to shared memory block photo");
	}

	shared_memory.lock();
	int size = shared_memory.size();
	if (size != sizeof(unsigned int) * NPIXELX * NPIXELY * NCHANNELS) {
		shared_memory.unlock();
		shared_memory.detach();
		IDL_MessageFromBlock(bam_cxc_msg_block, BAM_CXC_ERROR, IDL_MSG_LONGJMP, "Unexpected size for shared memory block photo");
	
	}
	const unsigned int *data = (const unsigned int *) shared_memory.data();
	unsigned int *data_copy = (unsigned int *) malloc(sizeof(unsigned int) * NPIXELX * NPIXELY * NCHANNELS);
	memcpy(data_copy, data, sizeof(unsigned int) * NPIXELX * NPIXELY * NCHANNELS);

	shared_memory.unlock();
	shared_memory.detach();

	int n_dim = 3;
	IDL_MEMINT dim[3] = {NCHANNELS, NPIXELY, NPIXELX};
	IDL_VPTR rv = IDL_ImportArray(n_dim, dim, IDL_TYP_ULONG, (UCHAR *) data_copy, (IDL_ARRAY_FREE_CB) free, 0);

	return rv;
}
Пример #3
0
IDL_VPTR IDL_CDECL idl_bam_cxc_get_event(int argc, IDL_VPTR argv[]) {

	unsigned long int *data = get_shared_memory("event");
	
	int n_dim = 2;
	IDL_MEMINT dim[2] = {NPIXELY, NPIXELX};
	IDL_VPTR rv = IDL_ImportArray(n_dim, dim, IDL_TYP_ULONG64, (UCHAR *) data, (IDL_ARRAY_FREE_CB) free, 0);

	return rv;
}
Пример #4
0
/**
 * Get the names of all the data elements which are children of the primary raster element.
 *
 * @param[in] WINDOW @opt
 *            The name of the window. Defaults to the active window.
 * @return An array of data element names or the string "failure" if an error occurred.
 * @usage names = get_data_element_names()
 * @endusage
 */
IDL_VPTR get_data_element_names(int argc, IDL_VPTR pArgv[], char* pArgk)
{
   typedef struct
   {
      IDL_KW_RESULT_FIRST_FIELD;
      int windowExists;
      IDL_STRING windowName;
   } KW_RESULT;

   //IDL_KW_FAST_SCAN is the type of scan we are using, following it is the
   //name of the keyword, followed by the type, the mask(which should be 1),
   //flags, a boolean whether the value was populated and finally the value itself
   static IDL_KW_PAR kw_pars[] = {
      IDL_KW_FAST_SCAN,
      {"WINDOW", IDL_TYP_STRING, 1, 0, reinterpret_cast<int*>(IDL_KW_OFFSETOF(windowExists)),
         reinterpret_cast<char*>(IDL_KW_OFFSETOF(windowName))},
      {NULL}
   };

   IdlFunctions::IdlKwResource<KW_RESULT> kw(argc, pArgv, pArgk, kw_pars, 0, 1);
   std::string windowName;
   std::string name;
   bool bSuccess = false;
   IDL_VPTR idlPtr;
   unsigned int total = 0;
   IDL_STRING* pStrarr = NULL;

   if (kw->windowExists)
   {
      windowName = IDL_STRING_STR(&kw->windowName);
   }

   SpatialDataWindow* pWindow = NULL;
   if (windowName.empty())
   {
      pWindow = dynamic_cast<SpatialDataWindow*>(Service<DesktopServices>()->getCurrentWorkspaceWindow());
   }
   else
   {
      pWindow = dynamic_cast<SpatialDataWindow*>(
         Service<DesktopServices>()->getWindow(windowName, SPATIAL_DATA_WINDOW));
   }
   if (pWindow != NULL)
   {
      SpatialDataView* pView = pWindow->getSpatialDataView();
      if (pView != NULL)
      {
         LayerList* pList = pView->getLayerList();
         if (pList != NULL)
         {
            RasterElement* pElement = pList->getPrimaryRasterElement();
            if (pElement != NULL)
            {
               std::vector<std::string> names = Service<ModelServices>()->getElementNames(pElement, "");
               total = names.size();
               if (total > 0)
               {
                  pStrarr = reinterpret_cast<IDL_STRING*>(malloc(total * sizeof(IDL_STRING)));
                  for (unsigned int i=0; i < total; ++i)
                  {
                     IDL_StrStore(&(pStrarr[i]), const_cast<char*>(names[i].c_str()));
                  }
                  bSuccess = true;
               }
            }
         }
      }
   }
   else if (windowName == "all")
   {
      std::vector<std::string> names = Service<ModelServices>()->getElementNames("RasterElement");
      total = names.size();
      if (total > 0)
      {
         pStrarr = reinterpret_cast<IDL_STRING*>(malloc(total* sizeof(IDL_STRING)));
         for (unsigned int i=0; i < total; ++i)
         {
            IDL_StrStore(&(pStrarr[i]), const_cast<char*>(names[i].c_str()));
         }
         bSuccess = true;
      }
   }
   if (!bSuccess)
   {
      IDL_Message(IDL_M_GENERIC, IDL_MSG_RET, "No elements matched.");
      return IDL_StrToSTRING("failure");
   }
   IDL_MEMINT dims[] = {total};
   idlPtr = IDL_ImportArray(1, dims, IDL_TYP_STRING, reinterpret_cast<UCHAR*>(pStrarr),
      reinterpret_cast<IDL_ARRAY_FREE_CB>(free), NULL);
   return idlPtr;
}
Пример #5
0
// MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res);
static IDL_VPTR IDL_mg_mysql_fetch_field(int argc, IDL_VPTR *argv) {
    static IDL_MEMINT nfields = 1;
    MYSQL_FIELD *field = mysql_fetch_field((MYSQL_RES *)argv[0]->value.ptrint);
    typedef struct field {
        IDL_STRING name;
        IDL_STRING org_name;
        IDL_STRING table;
        IDL_STRING org_table;
        IDL_STRING db;
        IDL_STRING catalog;
        IDL_STRING def;
        IDL_ULONG64 length;
        IDL_ULONG64 max_length;
        IDL_ULONG name_length;
        IDL_ULONG org_name_length;
        IDL_ULONG table_length;
        IDL_ULONG org_table_length;
        IDL_ULONG db_length;
        IDL_ULONG catalog_length;
        IDL_ULONG def_length;
        IDL_ULONG flags;
        IDL_ULONG decimals;
        IDL_ULONG charsetnr;
        IDL_ULONG type;
#if MYSQL_VERSION_ID >= 50100
        IDL_PTRINT extension;
#endif
    } MG_Field;
    MG_Field *mg_field_data = (MG_Field *) calloc(nfields, sizeof(MG_Field));
    void *idl_field_data;

    IDL_StrStore(&mg_field_data->name, field->name);
    IDL_StrStore(&mg_field_data->org_name, field->org_name);
    IDL_StrStore(&mg_field_data->table, field->table);
    IDL_StrStore(&mg_field_data->org_table, field->org_table);
    IDL_StrStore(&mg_field_data->db, field->db);
    IDL_StrStore(&mg_field_data->catalog, field->catalog);
    IDL_StrStore(&mg_field_data->def, field->def);

    mg_field_data->length = field->length;
    mg_field_data->max_length = field->max_length;

    mg_field_data->name_length = field->name_length;
    mg_field_data->org_name_length = field->org_name_length;
    mg_field_data->table_length = field->table_length;
    mg_field_data->org_table_length = field->org_table_length;
    mg_field_data->db_length = field->db_length;
    mg_field_data->catalog_length = field->catalog_length;
    mg_field_data->def_length = field->def_length;
    mg_field_data->flags = field->flags;
    mg_field_data->decimals = field->decimals;
    mg_field_data->charsetnr = field->charsetnr;
    mg_field_data->type = field->type;

#if MYSQL_VERSION_ID >= 50100
    mg_field_data->extension = (IDL_PTRINT)field->extension;
#endif

    idl_field_data = IDL_MakeStruct(0, mg_mysql_field);
    IDL_VPTR result = IDL_ImportArray(1,
                                      &nfields,
                                      IDL_TYP_STRUCT,
                                      (UCHAR *) mg_field_data,
                                      0,
                                      idl_field_data);
    return result;
}
Пример #6
0
IDL_VPTR readwu(int argc, IDL_VPTR argv[], char *argk) {
  IDL_VPTR filename=NULL;
  static IDL_VARIABLE rv;
  rv.type=IDL_TYP_INT;
  rv.flags=IDL_V_CONST|IDL_V_NULL;
  rv.value.i=-1;

  char *outfile=NULL, buf[256];
  struct stat statbuf;
  int nbytes,nread,nsamples;
  std::string tmpbuf("");
  int i=0,j;

  if (argc != 1) {
    fprintf(stderr,"argc=%d\n",argc);
    fprintf(stderr,"array=readwu(wufile_name)\n");
    return &rv;
  }
  IDL_STRING *infile=NULL;
  if (argv[0]->type != IDL_TYP_STRING) {
    IDL_MessageFromBlock(readwu_msg_block,0,IDL_MSG_RET,"Parameter 1 must be type STRING");
  } else {
    infile=(IDL_STRING *)(&argv[0]->value.s);
  }
  FILE *in=fopen(infile->s,"r");
  if (!in) {
    IDL_MessageFromBlock(readwu_msg_block,0,IDL_MSG_RET,"File not found");
    return &rv;
  } 
  stat(infile->s,&statbuf);
  nbytes=statbuf.st_size;
  fseek(in,0,SEEK_SET);
  tmpbuf.reserve(nbytes);
  // read entire file into a buffer.
  while ((nread=(int)fread(buf,1,sizeof(buf),in))) {
    tmpbuf+=std::string(&(buf[0]),nread);
  }
  // parse the header
  header.parse_xml(tmpbuf);
  // decode the data
  std::vector<unsigned char> datav(
    xml_decode_field<unsigned char>(tmpbuf,"data") 
  );
  tmpbuf.clear();
  nsamples=header.group_info->data_desc.nsamples;
  nbytes=nsamples*header.group_info->recorder_cfg->bits_per_sample/8;
  if (datav.size() < nbytes) {
    fprintf(stderr,"Data size does not match number of samples\n");
    return &rv;
  }
  // convert the data to floating point
  sah_complex *fpdata=(sah_complex *)IDL_MemAlloc(nsamples*sizeof(sah_complex),0,IDL_MSG_RET);
  if (!fpdata) {
    fprintf(stderr,"Unable to allocate memory!\r\n");
    return &rv;
  } 
  bits_to_floats(&(datav[0]),fpdata,nsamples);
  datav.clear();
  IDL_MEMINT dims[]={nsamples};
  return IDL_ImportArray(1,dims,IDL_TYP_COMPLEX,(UCHAR *)fpdata,NULL,NULL);
}