void bubble_2_arrays(
float* median_array, int* position_array, int index,
int length)
{
if(index > 0 && index < length -1){
if(median_array[index] < median_array[index-1]){
swap_float(median_array, index, index-1);
swap_integer(position_array, index, index-1);
bubble_2_arrays(median_array, position_array, index-1, length);
}else if(median_array[index] > median_array[index+1]){
swap_float(median_array, index, index+1);
swap_integer(position_array, index, index+1);
bubble_2_arrays(median_array, position_array, index+1, length);
}
}else if(index == 0){
if(median_array[index] > median_array[index+1]){
swap_float(median_array, index, index+1);
swap_integer(position_array, index, index+1);
bubble_2_arrays(median_array, position_array, index+1, length);
}
}else if(index == length -1){
if(median_array[index] < median_array[index-1]){
swap_float(median_array, index, index-1);
swap_integer(position_array, index, index-1);
bubble_2_arrays(median_array, position_array, index-1, length);
}
}
return;
}
/* inplace transpose of 3x3 matrix */
float* transposem_inplace_3f( float *M )
{
swap_float( M[1], M[3] );
swap_float( M[2], M[6] );
swap_float( M[5], M[7] );
return M;
}
CRIOGPSPacket CrioReceiver::swapGPSPacket(CRIOGPSPacket& packet) {
CRIOGPSPacket swapped_packet = packet;
swapped_packet.latitude = swap_double(packet.latitude);
swapped_packet.longitude = swap_double(packet.longitude);
swapped_packet.lat_std_dev = swap_float(packet.lat_std_dev);
swapped_packet.long_std_dev = swap_float(packet.long_std_dev);
swapped_packet.solution_status = be32toh(packet.solution_status);
swapped_packet.position_type = be32toh(packet.position_type);
swapped_packet.differential_age = swap_float(packet.differential_age);
swapped_packet.solution_age = swap_float(packet.solution_age);
return swapped_packet;
}
int partition(float* median_array, int left, int right, int pivot_index)
{
float pivot_value = median_array[pivot_index];
swap_float(median_array, pivot_index, right);
int store_index = left;
for(int i=left; i < right; i++){
if(median_array[i] <= pivot_value){
swap_float(median_array, i, store_index);
store_index +=1;
}
}
swap_float(median_array, store_index, right);
return store_index;
}
static void swap_pipelinel_lft (PIPELINEL_LFT *data)
{
swap_int (&data->id);
swap_float (&data->depth_below_surface_level);
swap_short (&data->existence_category);
swap_float (&data->height_above_sea_bottom);
swap_short (&data->location_category);
swap_float (&data->overhead_clearance_category);
swap_short (&data->over_water_obstruction);
swap_short (&data->pipeline_type);
swap_short (&data->product_category);
swap_short (&data->tile_reference_identifier);
swap_int (&data->edge_primitive_key);
}
static void swap_hydrol_lft (HYDROL_LFT *data)
{
swap_int (&data->id);
swap_short (&data->accuracy_category);
swap_float (&data->contour_value);
swap_short (&data->hypsography_portrayal_category);
}
int main_swap_gen(int argc, char** argv)
{
swap_int();
swap_float();
return (EXIT_SUCCESS);
}
void send_float(char *name,float floating_point) /* includefile */
{
send_string(name);
if (swapout) swap_float(&floating_point);
fwrite(&floating_point,sizeof(float),1,output);
/*fprintf(stderr,"%f\n",floating_point);*/
}
float
le_to_native_float(float f)
{
if(set_endian() == BIG_ENDIAN)
return swap_float(f);
return f;
}
static void swap_hydline_lft (HYDLINE_LFT *data)
{
swap_int (&data->id);
swap_short (&data->accuracy_category);
swap_float (&data->contour_value);
swap_short (&data->tile_reference_identifier);
swap_int (&data->edge_primitive_key);
}
void swap_img(char *img, AnalyzeHeader hdr)
{
int i,sz=hdr.dim[1]*hdr.dim[2]*hdr.dim[3];
switch(hdr.datatype)
{
case UCHAR: break;
case SHORT: for(i=0;i<sz;i++) swap_short(&((short*)img)[i]); break;
case INT: for(i=0;i<sz;i++) swap_int(&((int*)img)[i]); break;
case FLOAT: for(i=0;i<sz;i++) swap_float(&((float*)img)[i]); break;
case RGBFLOAT: for(i=0;i<sz;i++) swap_rgbfloat(&((float*)img)[i]); break;
}
}
static void swap_dangera_aft (DANGERA_AFT *data)
{
swap_int (&data->id);
swap_short (&data->accuracy_category);
swap_short (&data->date);
swap_short (&data->existence_category);
swap_short (&data->hydrographic_depth_height_info);
swap_float (&data->hydrographic_depth);
swap_short (&data->value);
swap_short (&data->vertical_reference_category);
swap_short (&data->tile_reference_identifier);
swap_int (&data->face_primitive_key);
}
void ordenar_vetores(float *medias, int *segundo, int tamanho)
{
for (int i = 0; i < tamanho; i++){
float *atual; atual = &medias[i];
int *resultado; resultado = &segundo[i];
for (int j = i + 1; j < tamanho; j++){
if (*atual < medias[j]){
atual = &medias[j];
resultado = &segundo[j];
}
}
swap_float(atual, &medias[i]);
swap_int(resultado, &segundo[i]);
}
}
static void swap_hazarda_aft (HAZARDA_AFT *data)
{
swap_int (&data->id);
swap_short (&data->accuracy_category);
swap_short (&data->certainty);
swap_short (&data->date);
swap_short (&data->existence_category);
swap_short (&data->hydrographic_depth_height_info);
swap_float (&data->hydrographic_depth);
swap_short (&data->location_category);
swap_short (&data->sea_floor_feature_category);
swap_short (&data->severity);
swap_short (&data->value);
swap_short (&data->vertical_reference_category);
swap_short (&data->tile_reference_identifier);
swap_int (&data->face_primitive_key);
}
static void swap_lightsp_pft (LIGHTSP_PFT *data)
{
swap_int (&data->id);
swap_short (&data->accuracy_category);
swap_int (&data->broadcast_frequency[0]);
swap_int (&data->broadcast_frequency[1]);
swap_short (&data->color_code);
swap_short (&data->elevation);
swap_short (&data->hydrographic_light_type);
swap_short (&data->IALA_aid_category);
swap_short (&data->nominal_light_range);
swap_short (&data->nav_system_type[0]);
swap_short (&data->nav_system_type[1]);
swap_float (&data->light_period);
swap_short (&data->radar_reflector_attr);
swap_short (&data->sound_signal_type);
swap_short (&data->topmark_characteristic);
swap_short (&data->tile_reference_identifier);
swap_int (&data->entity_node_key);
}
void remove_extremos(float *notas, int quantidade, float *resultado)
{
float min = notas[0];
float max = notas[1];
if (min > max)
swap_float(&min, &max);
int k = 0;
for (int i = 2; i<quantidade; i++){
if (notas[i] < min){
resultado[k++] = min;
min = notas[i];
} else if (notas[i] > max) {
resultado[k++] = max;
max = notas[i];
} else {
resultado[k++] = notas[i];
}
}
}
static void swap_buoybcnp_pft (BUOYBCNP_PFT *data)
{
swap_int (&data->id);
swap_short (&data->accuracy_category);
swap_int (&data->broadcast_frequency[0]);
swap_int (&data->broadcast_frequency[1]);
swap_short (&data->buoy_beacon_type);
swap_short (&data->color_code);
swap_short (&data->elevation);
swap_short (&data->nominal_light_range);
swap_short (&data->nav_system_type[0]);
swap_short (&data->nav_system_type[1]);
swap_short (&data->operating_range[0]);
swap_short (&data->operating_range[1]);
swap_float (&data->light_period);
swap_short (&data->radar_reflector_attr);
swap_short (&data->structure_shape_category);
swap_short (&data->sound_signal_type);
swap_short (&data->topmark_characteristic);
swap_short (&data->tile_reference_identifier);
swap_int (&data->entity_node_key);
}
void swap_hdr(AnalyzeHeader *hdr)
{
int i;
// header key
swap_int(&(*hdr).sizeof_hdr);
swap_int(&(*hdr).extents);
swap_short(&(*hdr).session_error);
// image dimension
for(i=0;i<8;i++) swap_short(&(*hdr).dim[i]);
for(i=0;i<7;i++) swap_short(&(*hdr).unused[i]);
swap_short(&(*hdr).datatype);
swap_short(&(*hdr).bitpix);
swap_short(&(*hdr).dim_un0);
for(i=0;i<8;i++) swap_float(&(*hdr).pixdim[i]);
swap_float(&(*hdr).vox_offset);
for(i=0;i<3;i++) swap_float(&(*hdr).funused[i]);
swap_float(&(*hdr).cal_max);
swap_float(&(*hdr).cal_min);
swap_float(&(*hdr).compressed);
swap_float(&(*hdr).verified);
swap_int(&(*hdr).glmax);
swap_int(&(*hdr).glmin);
// data history
for(i=0;i<3;i++) swap_short(&(*hdr).orig[i]);
swap_int(&(*hdr).views);
swap_int(&(*hdr).vols_added);
swap_int(&(*hdr).start_field);
swap_int(&(*hdr).field_skip);
swap_int(&(*hdr).omax);
swap_int(&(*hdr).omin);
swap_int(&(*hdr).smax);
swap_int(&(*hdr).smin);
}
void G_xdr_get_float(float *dst, const void *src)
{
swap_float(dst, src);
}
static void swapendian_BPP_header(BPP_SEARCH_HEADER * hdr)
/* This is required since it is a binary header */
{
int ii;
hdr->header_version = swap_int(hdr->header_version);
hdr->bit_mode = swap_int(hdr->bit_mode);
hdr->num_chans = swap_int(hdr->num_chans);
hdr->lmst = swap_int(hdr->lmst);
hdr->scan_file_number = swap_int(hdr->scan_file_number);
hdr->file_size = swap_int(hdr->file_size);
hdr->tape_num = swap_int(hdr->tape_num);
hdr->tape_file_number = swap_int(hdr->tape_file_number);
hdr->enabled_CBs = swap_int(hdr->enabled_CBs);
hdr->mb_start_address = swap_int(hdr->mb_start_address);
hdr->mb_end_address = swap_int(hdr->mb_end_address);
hdr->mb_start_board = swap_int(hdr->mb_start_board);
hdr->mb_end_board = swap_int(hdr->mb_end_board);
hdr->mb_vme_mid_address = swap_int(hdr->mb_vme_mid_address);
hdr->mb_ack_enabled = swap_int(hdr->mb_ack_enabled);
hdr->start_from_ste = swap_int(hdr->start_from_ste);
hdr->cb_sum_polarizations = swap_int(hdr->cb_sum_polarizations);
hdr->cb_direct_mode = swap_int(hdr->cb_direct_mode);
hdr->cb_accum_length = swap_int(hdr->cb_accum_length);
hdr->tb_outs_reg = swap_int(hdr->tb_outs_reg);
hdr->tb_ste = swap_int(hdr->tb_ste);
hdr->tb_stc = swap_int(hdr->tb_stc);
hdr->H_deci_factor = swap_int(hdr->H_deci_factor);
hdr->GenStat0 = swap_int(hdr->GenStat0);
hdr->GenStat1 = swap_int(hdr->GenStat1);
hdr->Ack_Reg = swap_int(hdr->Ack_Reg);
hdr->dfb_sram_length = swap_int(hdr->dfb_sram_length);
hdr->ASYMMETRIC = swap_int(hdr->ASYMMETRIC);
hdr->mb_long_ds0 = swap_int(hdr->mb_long_ds0);
hdr->aib_serial = swap_int(hdr->aib_serial);
hdr->aib_rev = swap_int(hdr->aib_rev);
hdr->BACKEND_TYPE = swap_int(hdr->BACKEND_TYPE);
hdr->UPDATE_DONE = swap_int(hdr->UPDATE_DONE);
hdr->HEADER_TYPE = swap_int(hdr->HEADER_TYPE);
hdr->tb_id = swap_int(hdr->tb_id);
hdr->aib_if_switch = swap_int(hdr->aib_if_switch);
hdr->mb_rev = swap_int(hdr->mb_rev);
hdr->mb_serial = swap_int(hdr->mb_serial);
hdr->tb_rev = swap_int(hdr->tb_rev);
hdr->tb_serial = swap_int(hdr->tb_serial);
hdr->mb_xtal_freq = swap_int(hdr->mb_xtal_freq);
hdr->scan_num = swap_uint(hdr->scan_num);
hdr->ll_file_offset = swap_longlong(hdr->ll_file_offset);
hdr->ll_file_size = swap_longlong(hdr->ll_file_size);
hdr->length_of_integration = swap_double(hdr->length_of_integration);
hdr->samp_rate = swap_double(hdr->samp_rate);
hdr->ra_2000 = swap_double(hdr->ra_2000);
hdr->dec_2000 = swap_double(hdr->dec_2000);
hdr->tele_x = swap_double(hdr->tele_x);
hdr->tele_y = swap_double(hdr->tele_y);
hdr->tele_z = swap_double(hdr->tele_z);
hdr->tele_inc = swap_double(hdr->tele_inc);
hdr->Fclk = swap_double(hdr->Fclk);
hdr->Har_Clk = swap_double(hdr->Har_Clk);
hdr->bandwidth = swap_double(hdr->bandwidth);
hdr->rf_lo = swap_double(hdr->rf_lo);
hdr->max_dfb_freq = swap_double(hdr->max_dfb_freq);
hdr->mjd_start = swap_longdouble(hdr->mjd_start);
for (ii = 0; ii < FB_CHAN_PER_BRD; ii++) {
hdr->dfb_sram_freqs[ii] = swap_float(hdr->dfb_sram_freqs[ii]);
}
for (ii = 0; ii < MAX_HARRIS_TAPS; ii++) {
hdr->i_hcoef[ii] = swap_int(hdr->i_hcoef[ii]);
hdr->q_hcoef[ii] = swap_int(hdr->q_hcoef[ii]);
}
for (ii = 0; ii < MAXNUMCB; ii++) {
hdr->cb_id[ii] = swap_int(hdr->cb_id[ii]);
hdr->cb_rev[ii] = swap_int(hdr->cb_rev[ii]);
hdr->cb_serial[ii] = swap_int(hdr->cb_serial[ii]);
hdr->cb_eprom_mode[ii] = swap_int(hdr->cb_eprom_mode[ii]);
}
for (ii = 0; ii < MAX_NUM_MF_BOARDS; ii++) {
hdr->mf_rev[ii] = swap_int(hdr->mf_rev[ii]);
hdr->mf_serial[ii] = swap_int(hdr->mf_serial[ii]);
hdr->mf_filt_width[ii] = swap_double(hdr->mf_filt_width[ii]);
hdr->mf_atten[ii] = swap_double(hdr->mf_atten[ii]);
}
for (ii = 0; ii < MAX_NUM_LO_BOARDS; ii++) {
hdr->lo_rev[ii] = swap_int(hdr->lo_rev[ii]);
hdr->lo_serial[ii] = swap_int(hdr->lo_serial[ii]);
hdr->aib_los[ii] = swap_double(hdr->aib_los[ii]);
}
for (ii = 0; ii < MAXNUMDFB; ii++) {
hdr->dfb_mixer_reg[ii] = swap_int(hdr->dfb_mixer_reg[ii]);
hdr->dfb_conf_reg[ii] = swap_int(hdr->dfb_conf_reg[ii]);
hdr->dfb_sram_addr_msb[ii] = swap_int(hdr->dfb_sram_addr_msb[ii]);
hdr->dfb_id[ii] = swap_int(hdr->dfb_id[ii]);
hdr->dfb_rev[ii] = swap_int(hdr->dfb_rev[ii]);
hdr->dfb_serial[ii] = swap_int(hdr->dfb_serial[ii]);
hdr->dfb_sun_program[ii] = swap_int(hdr->dfb_sun_program[ii]);
hdr->dfb_eprom[ii] = swap_int(hdr->dfb_eprom[ii]);
hdr->dfb_sram_addr[ii] = swap_int(hdr->dfb_sram_addr[ii]);
hdr->dfb_har_addr[ii] = swap_int(hdr->dfb_har_addr[ii]);
hdr->dfb_clip_adc_neg8[ii] = swap_int(hdr->dfb_clip_adc_neg8[ii]);
hdr->dfb_shften_[ii] = swap_int(hdr->dfb_shften_[ii]);
hdr->dfb_fwd_[ii] = swap_int(hdr->dfb_fwd_[ii]);
hdr->dfb_rvrs_[ii] = swap_int(hdr->dfb_rvrs_[ii]);
hdr->dfb_asymmetric[ii] = swap_int(hdr->dfb_asymmetric[ii]);
hdr->dfb_i_dc[ii] = swap_double(hdr->dfb_i_dc[ii]);
hdr->dfb_q_dc[ii] = swap_double(hdr->dfb_q_dc[ii]);
hdr->dfb_gain[ii] = swap_double(hdr->dfb_gain[ii]);
}
}
void pspm2fb(FILE *input, FILE *output) /* includefile */
{
FILE *fpou;
int np=0,ns,nc,c,s,nints,rawdata[PSPM_INT_BLOCK],idump,doit,swap_bytes;
int i,opened=0,drift;
float datablock[PSPM_REA_BLOCK],datablock2[PSPM_REA_BLOCK],sum,realtime;
unsigned char charblock[PSPM_REA_BLOCK],sample;
unsigned short shortblock[PSPM_REA_BLOCK];
char string[80];
/* establish whether this is drift-mode data */
if (pspm_search.HEADER_TYPE == 0) {
drift=1;
} else {
drift=0;
}
idump=0;
/* establish whether we need to swap bytes (PSPM is big endian) */
swap_bytes=little_endian();
/* shorthand for number of samples and channels in a datablock */
ns=PSPM_SAM_BLOCK;
nc=PSPM_NCH_BLOCK;
if (headerfile) {
/* write output ASCII header file */
fpou=open_file("head","w");
fprintf(fpou,"Original PSPM file: %s\n",inpfile);
fprintf(fpou,"Sample time (us): %f\n",tsamp*1.0e6);
fprintf(fpou,"Number of samples/record: %d\n",ns);
fprintf(fpou,"Center freq (MHz): %f\n",fch1+(float)nchans*foff/2.0);
fprintf(fpou,"Channel band (kHz): %f\n",fabs(foff)*1000.0);
fprintf(fpou,"Number of channels/record: %d\n",nc);
fprintf(fpou,"Time stamp (MJD): %18.12f\n",tstart);
fprintf(fpou,"AZ at start: %f\n",az_start);
fprintf(fpou,"ZA at start: %f\n",za_start);
fprintf(fpou,"RA (J2000): %f\n",src_raj);
fprintf(fpou,"DEC (J2000): %f\n",src_dej);
fclose(fpou);
}
/* main loop over each record of input data file*/
while (!feof(input)) {
/* this is the time at that start of the block */
realtime=tsamp*idump;
/* read in a record and unscramble the channels */
nints=fread(rawdata,sizeof(int),PSPM_INT_BLOCK,input);
if ( (doit=process(realtime,start_time,final_time)) == -1) break;
if (doit) {
/* about to process this record, update log */
np++;
if (np%10 == 0) {
if (!opened) {
/* open up logfile */
open_log("filterbank.monitor");
opened=1;
}
sprintf(string,"time:%.1fs",realtime);
update_log(string);
}
if (swap_bytes) for (s=0;s<nints;s++) swap_int(&rawdata[s]);
/* unscramble the channels using Ingrid's C routine */
pspm_decode(rawdata,datablock);
/* if the -invert option was specified, flip the band */
i=0;
if (invert_band) {
for(s=0;s<ns;s++) {
for (c=nc-1;c>=0;c--) {
datablock2[i++]=datablock[s*nc+c];
}
}
for(i=0;i<ns*nc;i++)
datablock[i]=datablock2[i];
}
realtime+=(float) ns * (float) tsamp;
/* decide on how to write out data */
if (obits==32) {
/* user has requested floating point numbers in binary file */
if (swapout) for (s=0;s<ns*nc;s++) swap_float(&datablock[s]);
fwrite(datablock,sizeof(float),ns*nc,output);
} else if (obits==16) {
/* user has requested unsigned shorts in binary file */
float2short(datablock,ns*nc,0.0,15.0,shortblock);
if (swapout) for (s=0;s<ns*nc;s++) swap_short(&shortblock[s]);
fwrite(shortblock,sizeof(unsigned short),ns*nc,output);
} else if (obits==8) {
/* user has requested unsigned chars in binary file */
float2char(datablock,ns*nc,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),ns*nc,output);
} else if (obits==4) {
/* default is to write data out packed into character format */
float2four(datablock,ns*nc,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),ns*nc/2,output);
} else if (obits==0) {
/* special mode to write out in different order for old ddsp program */
for (c=0;c<nc;c++) {
for(s=0;s<ns;s++) {
sample=(unsigned char)datablock[s*nc+c];
fwrite(&sample,sizeof(unsigned char),1,output);
}
}
} else {
error_message("unknown bit format for writing");
}
}
/* update dumps read/processed */
idump+=ns;
/* break out if this is in drift-mode and we've read 9 beams */
if (drift && (idump == 4718592)) break;
}
}
void G_xdr_put_float(void *dst, const float *src)
{
swap_float(dst, src);
}
void bpp2fb(FILE *input, FILE *output) /* includefile */
{
FILE *fpou;
int np,ns,nc,i,c,b,s,nchars,idump,doit,opened,nsblk,i1,i2,*chtab,blocksize;
float *tempblock, *datablock,realtime=0.0;
unsigned char *charblock,sample;
static unsigned char *charcarry;
unsigned short *shortblock;
char string[80];
int nshift[8] = {28,24,20,16,12,8,4,0};
static int ncarryover;
static int first = 1;
static int fileidx_start=1,file_count=1;
static double end_time;
double scantime,sample_start,sample_final;
int sample_skip,bytestart;
int bytefinal,fileidx_final,sample_diff,byte_diff=0;
int bpp_headersize = 32768;
int rd_jnq=0;
double sample_end,byte_end;
np=idump=opened=0;
ns=512;
blocksize=ns*nchans;
nc=nchans;
if(first) {
charcarry = (unsigned char *) malloc(sizeof(unsigned char)*blocksize);
ncarryover = 0;
first = 0;
scantime = (double)((double)bpp_search.file_size)/((double)(nchans/2))*bpp_search.samp_rate*1.e-6;
if(start_time){
fileidx_start = ceil(start_time/scantime);
file_count = fileidx_start;
sample_skip = floor(start_time/tsamp);
sample_start = sample_skip - (double)((fileidx_start-1)*(scantime/(double)tsamp));
bytestart = (sample_start*(double)nchans)/2.;
if(bytestart<blocksize/2){
bytestart+=(double)bpp_search.file_size-blocksize/2;
fileidx_start-=1;
file_count -=1;
sample_skip -= ns;
sample_start = sample_skip - (double)((fileidx_start-1)*(scantime/(double)tsamp));
}
realtime += sample_skip*(double)tsamp - scantime*(fileidx_start-1);
if((rd_jnq =fseek(input,bytestart,SEEK_CUR)< 0)) fprintf(stderr,"Error seeking to data byte %d in file\n",bytestart);
}
if(final_time){
sample_end = ceil(final_time/(double)tsamp);
fileidx_final = ceil(final_time/scantime);
sample_final = sample_end-(double)((fileidx_final-1)*scantime/tsamp);
byte_end = ceil(final_time/(double)tsamp)*(double)nchans/2;
bytefinal = (double)sample_final*(double)nchans/2;
end_time = (double)(byte_end/((double)nchans/2)*(double)tsamp);
fprintf(stderr,"Ending Time: \n");
fprintf(stderr," End File # %2d\n",fileidx_final);
fprintf(stderr," End Sample # %12.3f\n",sample_final);
fprintf(stderr," End Time (s) %12.5f (w.r.t. File # 1)\n",end_time);
if(start_time) {
end_time -= (double)((fileidx_start-1)*scantime);
fprintf(stderr," End Time (s) %12.5f (w.r.t. File # %d)\n",end_time,fileidx_start);
}
}
if (!final_time) end_time = 1000*scantime;
}
tempblock = (float *) malloc(sizeof(float)*blocksize);
datablock = (float *) malloc(sizeof(float)*blocksize);
charblock = (unsigned char *) malloc(sizeof(unsigned char)*blocksize);
shortblock = (unsigned short *) malloc(sizeof(unsigned short)*blocksize);
if (headerfile) {
/* write output ASCII header file */
fpou=open_file("head","w");
fprintf(fpou,"Original BPP file: %s\n",inpfile);
fprintf(fpou,"Sample time (us): %f\n",tsamp*1.0e6);
fprintf(fpou,"Number of samples/record: %d\n",ns);
fprintf(fpou,"Center freq (MHz): %f\n",fch1+(float)nchans*foff/2.0);
fprintf(fpou,"Channel band (kHz): %f\n",fabs(foff)*1000.0);
fprintf(fpou,"Number of channels/record: %d\n",nc);
fprintf(fpou,"Time stamp (MJD): %18.12f\n",tstart);
fprintf(fpou,"AZ at start: %f\n",az_start);
fprintf(fpou,"ZA at start: %f\n",za_start);
fprintf(fpou,"RA (J2000): %f\n",src_raj);
fprintf(fpou,"DEC (J2000): %f\n",src_dej);
fclose(fpou);
}
chtab=bpp_chans(bpp_search.bandwidth,bpp_search.mb_start_address,
bpp_search.mb_end_address,bpp_search.mb_start_board,
bpp_search.mb_end_board,bpp_search.cb_id,
bpp_search.aib_los,bpp_search.dfb_sram_freqs,
bpp_search.rf_lo);
/************************************************/
/* main loop over each record of input data file*/
/************************************************/
while (!feof(input)&& realtime<=end_time) {
/* read in a record */
if(!ncarryover) /* No data left from previous file */
nchars=fread(charblock,sizeof(unsigned char),blocksize/2,input);
if(ncarryover>0) { /* Add to partial block left from previous file */
nchars=fread(charblock,sizeof(unsigned char),(blocksize/2-ncarryover),input);
for(c=0;c<nchars;c++)
charblock[c+ncarryover] = charblock[c];
for(c=0;c<ncarryover;c++)
charblock[c] = charcarry[c];
ncarryover = 0;
nchars = blocksize/2;
fprintf(stderr," Starting at beginning of File # %d\n",file_count);
}
if(!ncarryover && nchars<blocksize/2) { /* Don't process, just keep */
ncarryover = nchars;
for(c=0;c<nchars;c++)
charcarry[c] = charblock[c];
file_count++;
if(final_time) end_time = end_time - (double)tsamp*(int)(scantime/(double)tsamp);
fprintf(stderr,"Advancing to file # %d\n",file_count);
/* if(final_time) fprintf(stderr," End time = %f (w.r.t. file # %d)\n",end_time,file_count);*/
/* fprintf(stderr," Realtime is %f\n",realtime);*/
}
else {
/* decide whether to process it */
if ( (doit=process(realtime,sample_skip*(double)tsamp,end_time)) == -1) {
fprintf(stderr,"realtime at time of break = %f (s)\n ",realtime);
break;
}
doit = 1;
if (doit) {
/* about to process this record, update log */
np++;
if (np%10 == 0) {
if (!opened) {
open_log("filterbank.monitor");
opened=1;
}
sprintf(string,"time:%.1fs",realtime);
update_log(string);
}
/* unscramble the 4-bit data into the float tempblock */
nsblk=0;
for (c=0;c<nchars;c++) {
char2ints(charblock[c],&i1,&i2);
tempblock[nsblk++] = (float) i2;
tempblock[nsblk++] = (float) i1;
}
/* update wallclock time */
realtime+=(float) (nsblk/nchans/nifs) * (float) tsamp;
if (sumifs) for (s=0;s<nsblk;s++) datablock[s]=0.0;
s=i1=i2=0;
/* loop over all samples, summing IFs 1+2 -> total power if neccessary */
while (s<nsblk) {
for (i=0;i<nifs;i++) {
for (c=0;c<nchans;c++) {
if (sumifs) {
if (i<2) datablock[i1+c]+=tempblock[i2+chtab[i*nchans+c]];
} else {
datablock[i1+i*nchans+c]=tempblock[i2+chtab[i*nchans+c]];
}
s++;
}
}
/* update internal counters */
i2+=nifs*nchans;
if (sumifs) {
i1+=nchans;
} else {
i1+=nifs*nchans;
}
}
/* divide by 2 to in sumif mode to allow for 4-bit packing */
if (sumifs) {
nsblk/=nifs;
for (s=0;s<nsblk;s++) datablock[s]/=2.0;
}
/* decide on how to write out data */
if (obits==32) {
/* user has requested floating point numbers in binary file */
if (swapout) for (s=0;s<nsblk;s++) swap_float(&datablock[s]);
fwrite(datablock,sizeof(float),nsblk,output);
} else if (obits==16) {
/* user has requested unsigned shorts in binary file */
float2short(datablock,nsblk,0.0,15.0,shortblock);
if (swapout) for (s=0;s<nsblk;s++) swap_short(&shortblock[s]);
fwrite(shortblock,sizeof(unsigned short),nsblk,output);
} else if (obits==8) {
/* user has requested unsigned chars in binary file */
float2char(datablock,nsblk,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),nsblk,output);
} else if (obits==4) {
/* default is to write data out packed into character format */
float2four(datablock,nsblk,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),nsblk/2,output);
}
else {
error_message("unknown bit format for writing");
}
}
/* update dumps read/processed */
idump+=ns;
}
}
}
LogImageFile *dpxOpen(const unsigned char *byteStuff, int fromMemory, size_t bufferSize)
{
DpxMainHeader header;
LogImageFile *dpx = (LogImageFile *)MEM_mallocN(sizeof(LogImageFile), __func__);
const char *filename = (const char *)byteStuff;
int i;
if (dpx == NULL) {
if (verbose) printf("DPX: Failed to malloc dpx file structure.\n");
return NULL;
}
/* zero the header */
memset(&header, 0, sizeof(DpxMainHeader));
/* for close routine */
dpx->file = NULL;
if (fromMemory == 0) {
/* byteStuff is then the filename */
dpx->file = BLI_fopen(filename, "rb");
if (dpx->file == NULL) {
if (verbose) printf("DPX: Failed to open file \"%s\".\n", filename);
logImageClose(dpx);
return NULL;
}
/* not used in this case */
dpx->memBuffer = NULL;
dpx->memCursor = NULL;
dpx->memBufferSize = 0;
}
else {
dpx->memBuffer = (unsigned char *)byteStuff;
dpx->memCursor = (unsigned char *)byteStuff;
dpx->memBufferSize = bufferSize;
}
if (logimage_fread(&header, sizeof(header), 1, dpx) == 0) {
if (verbose) printf("DPX: Not enough data for header in \"%s\".\n", byteStuff);
logImageClose(dpx);
return NULL;
}
/* endianness determination */
if (header.fileHeader.magic_num == swap_uint(DPX_FILE_MAGIC, 1)) {
dpx->isMSB = 1;
if (verbose) printf("DPX: File is MSB.\n");
}
else if (header.fileHeader.magic_num == DPX_FILE_MAGIC) {
dpx->isMSB = 0;
if (verbose) printf("DPX: File is LSB.\n");
}
else {
if (verbose) {
printf("DPX: Bad magic number %u in \"%s\".\n",
header.fileHeader.magic_num, byteStuff);
}
logImageClose(dpx);
return NULL;
}
dpx->srcFormat = format_DPX;
dpx->numElements = swap_ushort(header.imageHeader.elements_per_image, dpx->isMSB);
if (dpx->numElements == 0) {
if (verbose) printf("DPX: Wrong number of elements: %d\n", dpx->numElements);
logImageClose(dpx);
return NULL;
}
dpx->width = swap_uint(header.imageHeader.pixels_per_line, dpx->isMSB);
dpx->height = swap_uint(header.imageHeader.lines_per_element, dpx->isMSB);
if (dpx->width == 0 || dpx->height == 0) {
if (verbose) printf("DPX: Wrong image dimension: %dx%d\n", dpx->width, dpx->height);
logImageClose(dpx);
return NULL;
}
dpx->depth = 0;
for (i = 0; i < dpx->numElements; i++) {
dpx->element[i].descriptor = header.imageHeader.element[i].descriptor;
switch (dpx->element[i].descriptor) {
case descriptor_Red:
case descriptor_Green:
case descriptor_Blue:
case descriptor_Alpha:
case descriptor_Luminance:
case descriptor_Chrominance:
dpx->depth++;
dpx->element[i].depth = 1;
break;
case descriptor_CbYCrY:
dpx->depth += 2;
dpx->element[i].depth = 2;
break;
case descriptor_RGB:
case descriptor_CbYCr:
case descriptor_CbYACrYA:
dpx->depth += 3;
dpx->element[i].depth = 3;
break;
case descriptor_RGBA:
case descriptor_ABGR:
case descriptor_CbYCrA:
dpx->depth += 4;
dpx->element[i].depth = 4;
break;
case descriptor_Depth:
case descriptor_Composite:
/* unsupported */
break;
}
if (dpx->depth == 0 || dpx->depth > 4) {
if (verbose) printf("DPX: Unsupported image depth: %d\n", dpx->depth);
logImageClose(dpx);
return NULL;
}
dpx->element[i].bitsPerSample = header.imageHeader.element[i].bits_per_sample;
if (dpx->element[i].bitsPerSample != 1 && dpx->element[i].bitsPerSample != 8 &&
dpx->element[i].bitsPerSample != 10 && dpx->element[i].bitsPerSample != 12 &&
dpx->element[i].bitsPerSample != 16)
{
if (verbose) printf("DPX: Unsupported bitsPerSample for elements %d: %d\n", i, dpx->element[i].bitsPerSample);
logImageClose(dpx);
return NULL;
}
dpx->element[i].maxValue = powf(2, dpx->element[i].bitsPerSample) - 1.0f;
dpx->element[i].packing = swap_ushort(header.imageHeader.element[i].packing, dpx->isMSB);
if (dpx->element[i].packing > 2) {
if (verbose) printf("DPX: Unsupported packing for element %d: %d\n", i, dpx->element[i].packing);
logImageClose(dpx);
return NULL;
}
/* Sometimes, the offset is not set correctly in the header */
dpx->element[i].dataOffset = swap_uint(header.imageHeader.element[i].data_offset, dpx->isMSB);
if (dpx->element[i].dataOffset == 0 && dpx->numElements == 1)
dpx->element[i].dataOffset = swap_uint(header.fileHeader.offset, dpx->isMSB);
if (dpx->element[i].dataOffset == 0) {
if (verbose) printf("DPX: Image header is corrupted.\n");
logImageClose(dpx);
return NULL;
}
dpx->element[i].transfer = header.imageHeader.element[i].transfer;
/* if undefined, assign default */
dpx->element[i].refLowData = swap_uint(header.imageHeader.element[i].ref_low_data, dpx->isMSB);
dpx->element[i].refLowQuantity = swap_float(header.imageHeader.element[i].ref_low_quantity, dpx->isMSB);
dpx->element[i].refHighData = swap_uint(header.imageHeader.element[i].ref_high_data, dpx->isMSB);
dpx->element[i].refHighQuantity = swap_float(header.imageHeader.element[i].ref_high_quantity, dpx->isMSB);
switch (dpx->element[i].descriptor) {
case descriptor_Red:
case descriptor_Green:
case descriptor_Blue:
case descriptor_Alpha:
case descriptor_RGB:
case descriptor_RGBA:
case descriptor_ABGR:
if (dpx->element[i].refLowData == DPX_UNDEFINED_U32)
dpx->element[i].refLowData = 0;
if (dpx->element[i].refHighData == DPX_UNDEFINED_U32)
dpx->element[i].refHighData = (unsigned int)dpx->element[i].maxValue;
if (dpx->element[i].refLowQuantity == DPX_UNDEFINED_R32 || isnan(dpx->element[i].refLowQuantity))
dpx->element[i].refLowQuantity = 0.0f;
if (dpx->element[i].refHighQuantity == DPX_UNDEFINED_R32 || isnan(dpx->element[i].refHighQuantity)) {
if (dpx->element[i].transfer == transfer_PrintingDensity || dpx->element[i].transfer == transfer_Logarithmic)
dpx->element[i].refHighQuantity = 2.048f;
else
dpx->element[i].refHighQuantity = dpx->element[i].maxValue;
}
break;
case descriptor_Luminance:
case descriptor_Chrominance:
case descriptor_CbYCrY:
case descriptor_CbYCr:
case descriptor_CbYACrYA:
case descriptor_CbYCrA:
if (dpx->element[i].refLowData == DPX_UNDEFINED_U32)
dpx->element[i].refLowData = 16.0f / 255.0f * dpx->element[i].maxValue;
if (dpx->element[i].refHighData == DPX_UNDEFINED_U32)
dpx->element[i].refHighData = 235.0f / 255.0f * dpx->element[i].maxValue;
if (dpx->element[i].refLowQuantity == DPX_UNDEFINED_R32 || isnan(dpx->element[i].refLowQuantity))
dpx->element[i].refLowQuantity = 0.0f;
if (dpx->element[i].refHighQuantity == DPX_UNDEFINED_R32 || isnan(dpx->element[i].refHighQuantity))
dpx->element[i].refHighQuantity = 0.7f;
break;
default:
break;
}
}
dpx->referenceBlack = swap_float(header.televisionHeader.black_level, dpx->isMSB);
dpx->referenceWhite = swap_float(header.televisionHeader.white_level, dpx->isMSB);
dpx->gamma = swap_float(header.televisionHeader.gamma, dpx->isMSB);
if ((dpx->referenceBlack == DPX_UNDEFINED_R32 || isnan(dpx->referenceBlack)) ||
(dpx->referenceWhite == DPX_UNDEFINED_R32 || dpx->referenceWhite <= dpx->referenceBlack || isnan(dpx->referenceWhite)) ||
(dpx->gamma == DPX_UNDEFINED_R32 || dpx->gamma <= 0 || isnan(dpx->gamma)))
{
dpx->referenceBlack = 95.0f / 1023.0f * dpx->element[0].maxValue;
dpx->referenceWhite = 685.0f / 1023.0f * dpx->element[0].maxValue;
dpx->gamma = 1.7f;
}
if (verbose) {
printf("size %d x %d x %d elements\n", dpx->width, dpx->height, dpx->numElements);
for (i = 0; i < dpx->numElements; i++) {
printf(" Element %d:\n", i);
printf(" Bits per sample: %d\n", dpx->element[i].bitsPerSample);
printf(" Depth: %d\n", dpx->element[i].depth);
printf(" Transfer characteristics: %d\n", dpx->element[i].transfer);
printf(" Packing: %d\n", dpx->element[i].packing);
printf(" Descriptor: %d\n", dpx->element[i].descriptor);
printf(" Data offset: %d\n", dpx->element[i].dataOffset);
printf(" Reference low data: %u\n", dpx->element[i].refLowData);
printf(" Reference low quantity: %f\n", dpx->element[i].refLowQuantity);
printf(" Reference high data: %u\n", dpx->element[i].refHighData);
printf(" Reference high quantity: %f\n", dpx->element[i].refHighQuantity);
printf("\n");
}
printf("Gamma: %f\n", dpx->gamma);
printf("Reference black: %f\n", dpx->referenceBlack);
printf("Reference white: %f\n", dpx->referenceWhite);
printf("----------------------------\n");
}
return dpx;
}
CRIOPosePacket CrioReceiver::swapPosePacket(CRIOPosePacket& packet) {
CRIOPosePacket swapped_packet = packet;
swapped_packet.x = swap_float(packet.x);
swapped_packet.y = swap_float(packet.y);
swapped_packet.theta = swap_float(packet.theta);
swapped_packet.vel = swap_float(packet.vel);
swapped_packet.omega = swap_float(packet.omega);
swapped_packet.yaw_bias = swap_float(packet.yaw_bias);
swapped_packet.x_variance = swap_float(packet.x_variance);
swapped_packet.y_variance = swap_float(packet.y_variance);
swapped_packet.theta_variance = swap_float(packet.theta_variance);
swapped_packet.omega_variance = swap_float(packet.omega_variance);
swapped_packet.vel_variance = swap_float(packet.vel_variance);
swapped_packet.yaw_bias_variance = swap_float(packet.yaw_bias_variance);
swapped_packet.sonar_ping_1 = swap_float(packet.sonar_ping_1);
swapped_packet.sonar_ping_2 = swap_float(packet.sonar_ping_2);
swapped_packet.sonar_ping_3 = swap_float(packet.sonar_ping_3);
swapped_packet.sonar_ping_4 = swap_float(packet.sonar_ping_4);
swapped_packet.sonar_ping_5 = swap_float(packet.sonar_ping_5);
return swapped_packet;
}
/* subtract current offset from the dedisperse time samples and write */
void write_dedisp(float *dedisp, int nsout, int nifs, int nbands, float *offset, FILE *output)/*includefile*/
{
int s,i,b,ixnb,sxib,n;
static int first=1;
static float *clipthreshold;
float *temp,outliers,sample,sumsq;
char *onebyte;
short *twobyte;
/* multiply outgoing data by Jansky calibration factor if supplied */
if (jyfactor != 1.0) for (i=0;i<nsout*nifs*nbands;i++) dedisp[i]*=jyfactor;
if (first) {
/* allocate an array for holding blocks from a given subband */
temp=malloc(sizeof(float)*nsout);
/* allocate an array for saving the clipping threshold */
clipthreshold=malloc(sizeof(float)*nbands*nifs);
for (i=0;i<nifs*nbands;i++) clipthreshold[i]=0.0;
}
for (i=0;i<nifs;i++) {
ixnb=i*nbands;
for (b=0;b<nbands;b++) {
if (first) {
/* copy sub-band into temporary store for absolute value */
for (s=0;s<nsout;s++) {
sxib=s*nifs*nbands;
temp[s]=fabs(dedisp[sxib+ixnb+b]-offset[ixnb+b]);
}
/* find the value below which 90% of the samples lie */
outliers=nrselect(nsout/10,nsout,temp-1);
n=0;
sumsq=0.0;
/* calculate sum of squares based on the inner 90% of samples */
for (s=0;s<nsout;s++) {
if (temp[s]<outliers) {
sumsq+=temp[s]*temp[s];
n++;
}
}
/* now set the threshold based on the sum of squares */
if (n)
clipthreshold[ixnb+b]=clipvalue*sqrt((double)sumsq/(double)n);
else
clipping=0;
}
for (s=0;s<nsout;s++) {
sxib=s*nifs*nbands;
/* subtract off median value of this block */
sample=dedisp[sxib+ixnb+b]-offset[ixnb+b];
/* clip this sample if it exceeds the threshold */
if (fabs(sample)>clipthreshold[ixnb+b] && clipping) sample=0.0;
/* store the final produce and swap bytes if necessary */
dedisp[sxib+ixnb+b]=sample;
if (swapout) swap_float(&dedisp[sxib+ixnb+b]);
}
}
}
/* now write out samples and bat on */
switch (nobits) {
case 8:
onebyte = (char *) malloc(nsout*nifs*nbands);
for (i=0; i<nsout*nifs*nbands; i++)
onebyte[i] = (char) dedisp[i];
fwrite(onebyte,sizeof(char),nsout*nifs*nbands,output);
break;
case 16:
twobyte = (short *) malloc(nsout*nifs*nbands);
for (i=0; i<nsout*nifs*nbands; i++)
twobyte[i] = (short) dedisp[i];
fwrite(twobyte,sizeof(short),nsout*nifs*nbands,output);
break;
case 32:
fwrite(dedisp,sizeof(float),nsout*nifs*nbands,output);
break;
default:
error_message("requested output number of bits can only be 8, 16 or 32");
break;
}
if (first) {
first=0;
free(temp);
}
}
LogImageFile *cineonOpen(const unsigned char *byteStuff, int fromMemory, size_t bufferSize)
{
CineonMainHeader header;
LogImageFile *cineon = (LogImageFile *)MEM_mallocN(sizeof(LogImageFile), __func__);
const char *filename = (const char *)byteStuff;
int i;
unsigned int dataOffset;
if (cineon == NULL) {
if (verbose) printf("Cineon: Failed to malloc cineon file structure.\n");
return NULL;
}
/* zero the header */
memset(&header, 0, sizeof(CineonMainHeader));
/* for close routine */
cineon->file = NULL;
if (fromMemory == 0) {
/* byteStuff is then the filename */
cineon->file = BLI_fopen(filename, "rb");
if (cineon->file == NULL) {
if (verbose) printf("Cineon: Failed to open file \"%s\".\n", filename);
logImageClose(cineon);
return NULL;
}
/* not used in this case */
cineon->memBuffer = NULL;
cineon->memCursor = NULL;
cineon->memBufferSize = 0;
}
else {
cineon->memBuffer = (unsigned char *)byteStuff;
cineon->memCursor = (unsigned char *)byteStuff;
cineon->memBufferSize = bufferSize;
}
if (logimage_fread(&header, sizeof(header), 1, cineon) == 0) {
if (verbose) printf("Cineon: Not enough data for header in \"%s\".\n", byteStuff);
logImageClose(cineon);
return NULL;
}
/* endianness determination */
if (header.fileHeader.magic_num == swap_uint(CINEON_FILE_MAGIC, 1)) {
cineon->isMSB = 1;
if (verbose) printf("Cineon: File is MSB.\n");
}
else if (header.fileHeader.magic_num == CINEON_FILE_MAGIC) {
cineon->isMSB = 0;
if (verbose) printf("Cineon: File is LSB.\n");
}
else {
if (verbose) printf("Cineon: Bad magic number %lu in \"%s\".\n",
(unsigned long)header.fileHeader.magic_num, byteStuff);
logImageClose(cineon);
return NULL;
}
cineon->width = swap_uint(header.imageHeader.element[0].pixels_per_line, cineon->isMSB);
cineon->height = swap_uint(header.imageHeader.element[0].lines_per_image, cineon->isMSB);
if (cineon->width == 0 || cineon->height == 0) {
if (verbose) printf("Cineon: Wrong image dimension: %dx%d\n", cineon->width, cineon->height);
logImageClose(cineon);
return NULL;
}
cineon->depth = header.imageHeader.elements_per_image;
cineon->srcFormat = format_Cineon;
if (header.imageHeader.interleave == 0)
cineon->numElements = 1;
else if (header.imageHeader.interleave == 2)
cineon->numElements = header.imageHeader.elements_per_image;
else {
if (verbose) printf("Cineon: Data interleave not supported: %d\n", header.imageHeader.interleave);
logImageClose(cineon);
return NULL;
}
if (cineon->depth == 1) {
/* Grayscale image */
cineon->element[0].descriptor = descriptor_Luminance;
cineon->element[0].transfer = transfer_Linear;
cineon->element[0].depth = 1;
}
else if (cineon->depth == 3) {
/* RGB image */
if (cineon->numElements == 1) {
cineon->element[0].descriptor = descriptor_RGB;
cineon->element[0].transfer = transfer_PrintingDensity;
cineon->element[0].depth = 3;
}
else if (cineon->numElements == 3) {
cineon->element[0].descriptor = descriptor_Red;
cineon->element[0].transfer = transfer_PrintingDensity;
cineon->element[0].depth = 1;
cineon->element[1].descriptor = descriptor_Green;
cineon->element[1].transfer = transfer_PrintingDensity;
cineon->element[1].depth = 1;
cineon->element[2].descriptor = descriptor_Blue;
cineon->element[2].transfer = transfer_PrintingDensity;
cineon->element[2].depth = 1;
}
}
else {
if (verbose) printf("Cineon: Cineon image depth unsupported: %d\n", cineon->depth);
logImageClose(cineon);
return NULL;
}
dataOffset = swap_uint(header.fileHeader.offset, cineon->isMSB);
for (i = 0; i < cineon->numElements; i++) {
cineon->element[i].bitsPerSample = header.imageHeader.element[i].bits_per_sample;
cineon->element[i].maxValue = powf(2, cineon->element[i].bitsPerSample) - 1.0f;
cineon->element[i].refLowData = swap_uint(header.imageHeader.element[i].ref_low_data, cineon->isMSB);
cineon->element[i].refLowQuantity = swap_float(header.imageHeader.element[i].ref_low_quantity, cineon->isMSB);
cineon->element[i].refHighData = swap_uint(header.imageHeader.element[i].ref_high_data, cineon->isMSB);
cineon->element[i].refHighQuantity = swap_float(header.imageHeader.element[i].ref_high_quantity, cineon->isMSB);
switch (header.imageHeader.packing) {
case 0:
cineon->element[i].packing = 0;
break;
case 5:
cineon->element[i].packing = 1;
break;
case 6:
cineon->element[i].packing = 2;
break;
default:
/* Not supported */
if (verbose) printf("Cineon: packing unsupported: %d\n", header.imageHeader.packing);
logImageClose(cineon);
return NULL;
}
if (cineon->element[i].refLowData == CINEON_UNDEFINED_U32)
cineon->element[i].refLowData = 0;
if (cineon->element[i].refHighData == CINEON_UNDEFINED_U32)
cineon->element[i].refHighData = (unsigned int)cineon->element[i].maxValue;
if (cineon->element[i].refLowQuantity == CINEON_UNDEFINED_R32 || isnan(cineon->element[i].refLowQuantity))
cineon->element[i].refLowQuantity = 0.0f;
if (cineon->element[i].refHighQuantity == CINEON_UNDEFINED_R32 || isnan(cineon->element[i].refHighQuantity)) {
if (cineon->element[i].transfer == transfer_PrintingDensity)
cineon->element[i].refHighQuantity = 2.048f;
else
cineon->element[i].refHighQuantity = cineon->element[i].maxValue;
}
cineon->element[i].dataOffset = dataOffset;
dataOffset += cineon->height * getRowLength(cineon->width, cineon->element[i]);
}
cineon->referenceBlack = 95.0f / 1023.0f * cineon->element[0].maxValue;
cineon->referenceWhite = 685.0f / 1023.0f * cineon->element[0].maxValue;
cineon->gamma = 1.7f;
if (verbose) {
printf("size %d x %d x %d elements\n", cineon->width, cineon->height, cineon->numElements);
for (i = 0; i < cineon->numElements; i++) {
printf(" Element %d:\n", i);
printf(" Bits per sample: %d\n", cineon->element[i].bitsPerSample);
printf(" Depth: %d\n", cineon->element[i].depth);
printf(" Transfer characteristics: %d\n", cineon->element[i].transfer);
printf(" Packing: %d\n", cineon->element[i].packing);
printf(" Descriptor: %d\n", cineon->element[i].descriptor);
printf(" Data offset: %u\n", cineon->element[i].dataOffset);
printf(" Reference low data: %u\n", cineon->element[i].refLowData);
printf(" Reference low quantity: %f\n", cineon->element[i].refLowQuantity);
printf(" Reference high data: %u\n", cineon->element[i].refHighData);
printf(" Reference high quantity: %f\n", cineon->element[i].refHighQuantity);
printf("\n");
}
printf("Gamma: %f\n", cineon->gamma);
printf("Reference black: %f\n", cineon->referenceBlack);
printf("Reference white: %f\n", cineon->referenceWhite);
printf("----------------------------\n");
}
return cineon;
}
static void fillDpxMainHeader(LogImageFile *dpx, DpxMainHeader *header, const char *filename, const char *creator)
{
time_t fileClock;
struct tm *fileTime;
memset(header, 0, sizeof(DpxMainHeader));
/* --- File header --- */
header->fileHeader.magic_num = swap_uint(DPX_FILE_MAGIC, dpx->isMSB);
header->fileHeader.offset = swap_uint(dpx->element[0].dataOffset, dpx->isMSB);
strcpy(header->fileHeader.version, "V2.0");
header->fileHeader.file_size = swap_uint(dpx->element[0].dataOffset + dpx->height * getRowLength(dpx->width, dpx->element[0]), dpx->isMSB);
header->fileHeader.ditto_key = 0;
header->fileHeader.gen_hdr_size = swap_uint(sizeof(DpxFileHeader) + sizeof(DpxImageHeader) + sizeof(DpxOrientationHeader), dpx->isMSB);
header->fileHeader.ind_hdr_size = swap_uint(sizeof(DpxFilmHeader) + sizeof(DpxTelevisionHeader), dpx->isMSB);
header->fileHeader.user_data_size = DPX_UNDEFINED_U32;
strncpy(header->fileHeader.file_name, filename, 99);
header->fileHeader.file_name[99] = 0;
fileClock = time(NULL);
fileTime = localtime(&fileClock);
strftime(header->fileHeader.creation_date, 24, "%Y:%m:%d:%H:%M:%S%Z", fileTime);
header->fileHeader.creation_date[23] = 0;
strncpy(header->fileHeader.creator, creator, 99);
header->fileHeader.creator[99] = 0;
header->fileHeader.project[0] = 0;
header->fileHeader.copyright[0] = 0;
header->fileHeader.key = 0xFFFFFFFF;
/* --- Image header --- */
header->imageHeader.orientation = 0;
header->imageHeader.elements_per_image = swap_ushort(1, dpx->isMSB);
header->imageHeader.pixels_per_line = swap_uint(dpx->width, dpx->isMSB);
header->imageHeader.lines_per_element = swap_uint(dpx->height, dpx->isMSB);
/* Fills element */
header->imageHeader.element[0].data_sign = 0;
header->imageHeader.element[0].ref_low_data = swap_uint(dpx->element[0].refLowData, dpx->isMSB);
header->imageHeader.element[0].ref_low_quantity = swap_float(dpx->element[0].refLowQuantity, dpx->isMSB);
header->imageHeader.element[0].ref_high_data = swap_uint(dpx->element[0].refHighData, dpx->isMSB);
header->imageHeader.element[0].ref_high_quantity = swap_float(dpx->element[0].refHighQuantity, dpx->isMSB);
header->imageHeader.element[0].descriptor = dpx->element[0].descriptor;
header->imageHeader.element[0].transfer = dpx->element[0].transfer;
header->imageHeader.element[0].colorimetric = 0;
header->imageHeader.element[0].bits_per_sample = dpx->element[0].bitsPerSample;
header->imageHeader.element[0].packing = swap_ushort(dpx->element[0].packing, dpx->isMSB);
header->imageHeader.element[0].encoding = 0;
header->imageHeader.element[0].data_offset = swap_uint(dpx->element[0].dataOffset, dpx->isMSB);
header->imageHeader.element[0].line_padding = 0;
header->imageHeader.element[0].element_padding = 0;
header->imageHeader.element[0].description[0] = 0;
/* --- Orientation header --- */
/* we leave it blank */
/* --- Television header --- */
header->televisionHeader.time_code = DPX_UNDEFINED_U32;
header->televisionHeader.user_bits = DPX_UNDEFINED_U32;
header->televisionHeader.interlace = DPX_UNDEFINED_U8;
header->televisionHeader.field_number = DPX_UNDEFINED_U8;
header->televisionHeader.video_signal = DPX_UNDEFINED_U8;
header->televisionHeader.padding = DPX_UNDEFINED_U8;
header->televisionHeader.horizontal_sample_rate = DPX_UNDEFINED_R32;
header->televisionHeader.vertical_sample_rate = DPX_UNDEFINED_R32;
header->televisionHeader.frame_rate = DPX_UNDEFINED_R32;
header->televisionHeader.time_offset = DPX_UNDEFINED_R32;
header->televisionHeader.gamma = swap_float(dpx->gamma, dpx->isMSB);
header->televisionHeader.black_level = swap_float(dpx->referenceBlack, dpx->isMSB);
header->televisionHeader.black_gain = DPX_UNDEFINED_R32;
header->televisionHeader.breakpoint = DPX_UNDEFINED_R32;
header->televisionHeader.white_level = swap_float(dpx->referenceWhite, dpx->isMSB);
header->televisionHeader.integration_times = DPX_UNDEFINED_R32;
}
void wapp2fb(FILE *input, FILE *output) /* includefile */
{
FILE *bptr, *fpou, *alfa[2];
int pixel[2];
double pra, pdec;
double bw, bandwidth, scale, power, hweight, tsamp_us, crate, lmst;
double *lag, *sum, *acf, *window, jan1, days, epoch, ras,des,rahr,dede;
float zerolag,*block,smin,smax;
int doit,i,j,k,two_nlags,nlags,stat,rec_size,idump,swap_bytes,ifnum,opened;
int filesize,headersize,beam,utsecs,iymdf[4],rah,ram,ded,dem;
unsigned char *cblock, zuc;
unsigned short *sblock, zus;
unsigned int zul;
char message[80], outfile[80];
void *dump;
static float realtime=0.0;
#ifdef FFTW
fftw_plan fftplan;
#endif
/* establish whether we need to swap bytes (WAPP is little endian) */
swap_bytes=big_endian();
/* initialise correlator parameters used below */
nlags=nchans;
two_nlags=2*nlags;
bandwidth=foff*nlags;
tsamp_us=tsamp*1.0e6;
if (bandwidth<0.0) bandwidth *= -1.0;
#ifdef FFTW
acf = fftw_malloc(sizeof(double) * two_nlags);
lag = fftw_malloc(sizeof(double) * two_nlags);
/* set up fftw table and acf array when computing power spectra */
fftplan=fftw_plan_r2r_1d(two_nlags,acf,lag,FFTW_R2HC,FFTW_PATIENT);
#endif
#ifndef FFTW
/* set up acf array when computing power spectra */
acf = (double *) malloc(two_nlags * sizeof(double));
lag = (double *) malloc(two_nlags * sizeof(double));
#endif
if (compute_spectra) {
/* ranges for scaling spectra */
smin=0.0;smax=3.0;
} else {
/* ranges for scaling correlation functions */
smin=-0.5;smax=1.0;
}
/* set up the weights for windowing of ACF to monimize FFT leakage */
if (hanning) {
/* Hanning window */
hweight=0.50;
} else if (hamming) {
/* Hamming window */
hweight=0.54;
} else {
/* no window (default) */
hweight=1.00;
}
/* define the smoothing window to be applied base on the above weight */
window = (double *) malloc(nlags * sizeof(double));
for (j=0; j<nlags; j++) window[j]=(hweight+(1.0-hweight)*cos(PI*j/nlags));
/* work out number of IFs to loop over */
if (sumifs && (nifs>1)) {
smin*=2.0;
smax*=2.0;
ifnum=2;
} else {
sumifs=0;
ifnum=nifs;
}
/* calculate required record size for reading - i.e. number of bytes/dump */
rec_size = nifs*nlags*(nbits/8);
dump = malloc(rec_size); /* pointer to the correlator dump */
/* correlator data rate */
crate = 1.0/(tsamp_us-WAPP_DEAD_TIME);
/* scale factor to normalize correlation functions */
if (bandwidth < 50.0)
bw=50.0; /* correct scaling for narrow-band use */
else
bw=bandwidth;
scale = crate/bw;
if (wapp_level==9) scale/=16.0; /* 9-level sampling */
if (wapp_sum) scale/=2.0; /* summed IFs (search mode) */
scale*=pow(2.0,(double)wapp_lagtrunc); /* needed for truncation modes */
/* now define a number of working arrays to store lags and spectra */
block = (float *) malloc(nlags * sizeof(float));
cblock = (unsigned char *) malloc(nlags * sizeof(unsigned char));
sblock = (unsigned short *) malloc(nlags * sizeof(unsigned short));
/* if the file is ALFA data --- do the demultiplexing to two files */
if (wapp_isalfa) {
angle_split(src_raj,&rah,&ram,&ras);
rahr=(double)rah+(double)ram/60.0+(double)ras/3600.0;
angle_split(src_dej,&ded,&dem,&des);
if (ded>0)
dede=(double)ded+(double)dem/60.0+(double)des/3600.0;
else
dede=(double)ded-(double)dem/60.0-(double)des/3600.0;
/* calculate local sidereal time in hours */
lmst=slaGmst(tstart)*12.0/4.0/atan(1.0)-4.4502051459439667;
if (lmst<0.0) lmst+=24.0;
slaDjcal(5,tstart,iymdf,&stat);
slaCaldj(iymdf[0],1,1,&jan1,&stat);
days=tstart-jan1+1.0;
epoch=(double)iymdf[0]+days/365.25;
utsecs=86400*(tstart-floor(tstart));
pixel[0]=(wapp_number-1)*2;
pixel[1]=pixel[0]+1;
puts("opening output files for demultiplexed ALFA data...");
for (i=0; i<2; i++) {
if (alfa_raj[pixel[i]] == 0.0) {
alfa_position(rahr,dede,lmst,epoch,alfa_ang,0.0,0.0,pixel[i],&pra,&pdec);
src_raj=h2hms(pra);
src_dej=deg2dms(pdec);
} else {
src_raj=h2hms(alfa_raj[pixel[i]]);
src_dej=deg2dms(alfa_dej[pixel[i]]);
}
sprintf(outfile,"%s_%.0f_%05d_%04d_%s_%d.fil",
project,floor(tstart),utsecs,
scan_number,source_name,pixel[i]);
alfa[i]=open_file(outfile,"wb");
puts(outfile);
filterbank_header(alfa[i]);
}
beam=0;
}
if (headerfile) {
/* write output ASCII header file */
fpou=open_file("head","w");
fprintf(fpou,"Original WAPP file: %s\n",inpfile);
fprintf(fpou,"Sample time (us): %f\n",tsamp_us);
fprintf(fpou,"Observation time (s): %f\n",wapp_obstime);
fprintf(fpou,"Time stamp (MJD): %18.12f\n",tstart);
fprintf(fpou,"Number of samples/record: %d\n",512);
fprintf(fpou,"Center freq (MHz): %f\n",fch1+(float)nlags*foff/2.0);
fprintf(fpou,"Channel band (kHz): %f\n",bandwidth*1000.0/nlags);
fprintf(fpou,"Number of channels/record: %d\n",nlags);
fprintf(fpou,"Nifs: %d\n",ifnum);
fprintf(fpou,"RA (J2000): %f\n",src_raj);
fprintf(fpou,"DEC (J2000): %f\n",src_dej);
fprintf(fpou,"Gal l: %.4f\n",srcl);
fprintf(fpou,"Gal b: %.4f\n",srcb);
fprintf(fpou,"Name: %s\n",source_name);
fprintf(fpou,"Lagformat: %d\n",wapp_lagformat);
fprintf(fpou,"Sum: %d\n",wapp_sum);
fprintf(fpou,"Level: %d\n",wapp_level);
fprintf(fpou,"AZ at start: %f\n",az_start);
fprintf(fpou,"ZA at start: %f\n",za_start);
fprintf(fpou,"AST at start: %f\n",ast0);
fprintf(fpou,"LST at start: %f\n",lst0);
fprintf(fpou,"Project ID: %s\n",project);
fprintf(fpou,"Observers: %s\n",culprits);
filesize=sizeof_file(inpfile);
fprintf(fpou,"File size (bytes): %d\n",filesize);
headersize=wapp_header_size+wapp_incfile_length;
fprintf(fpou,"Data size (bytes): %d\n",filesize-headersize);
fprintf(fpou,"Number of samples: %d\n",nsamples(inpfile,headersize,nbits,nifs,nchans));
fclose(fpou);
}
/* initialise various counters and flags */
opened=idump=i=j=0;
/* main loop reading data from infile until no more left to read */
while( (stat=read(wapp_file,dump,rec_size)) == rec_size) {
/* calculate elapsed time and determine whether we process this record */
realtime += (float) tsamp;
if ( (doit=process(realtime,start_time,final_time)) == -1) break;
if (doit) {
/* set ALFA beam output if necessary */
if (wapp_isalfa) {
output=alfa[beam]; /* set output file for this loop */
beam=!(beam); /* flip file for next iteration */
}
/* clear zerolag and blocksum arrays */
zerolag=0.0;
for (j=0; j<nlags; j++) block[j]=0.0;
/* loop over the IFs */
for (i=0; i<ifnum; i++) {
if (ifstream[i]=='Y') {
if (zerolagdump) {
/* only interested in the zero lag term for each IF */
switch (nbits) {
case 8:
zuc = *(((unsigned char *)dump)+i*nlags);
zerolag+=zuc;
break;
case 16:
zus = *(((unsigned short *)dump)+i*nlags);
if (swap_bytes) swap_short(&zus);
zerolag+=zus;
break;
case 32:
zul = *(((unsigned int *)dump)+i*nlags);
if (swap_bytes) swap_int(&zul);
zerolag+=zul;
break;
}
/* write out the data checking IF number for summed mode */
if ( (sumifs && (i==1)) || (!sumifs) ) {
if (obits==32) {
if (swapout) swap_float(&zerolag);
fwrite(&zerolag,sizeof(float),1,output);
} else {
sprintf(message,"cannot write %d bits in zerolag mode",obits);
error_message(message);
}
}
} else {
/* fill lag array with scaled CFs */
for (j=0; j<nlags; j++) {
switch (nbits) {
case 8:
zuc = *(((unsigned char *)dump)+j+i*nlags);
lag[j] = scale * (double) zuc - 1.0;
break;
case 16:
zus = *(((unsigned short *)dump)+j+i*nlags);
if (swap_bytes) swap_short(&zus);
lag[j] = scale * (double) zus - 1.0;
break;
case 32:
zul = *(((unsigned int *)dump)+j+i*nlags);
if (swap_bytes) swap_int(&zul);
lag[j] = scale * (double) zul - 1.0;
break;
}
}
/* calculate power and correct for finite level quantization */
power = inv_cerf(lag[0]);
power = 0.1872721836/power/power;
if (i<2) {
if (do_vanvleck) {
if (wapp_level==3) {
/* apply standard 3-level van vleck correction */
vanvleck3lev(lag,nlags);
} else if (wapp_level==9) {
/* apply 9-level van vleck correction */
vanvleck9lev(lag,nlags);
}
}
}
if (compute_spectra) {
/* form windowed even ACF in array */
for(j=1; j<nlags; j++) {
acf[j]=window[j]*lag[j]*power;
acf[two_nlags-j]=acf[j];
}
acf[nlags]=0.0;
acf[0]=lag[0]*power;
/* FFT the ACF (which is real and even) -> real and even FFT */
#ifdef FFTW
fftw_execute(fftplan);
#endif
#ifndef FFTW
rfft(two_nlags,acf,lag);
#endif
/* if the band needs to be flipped --- do it here */
if (wapp_flip) {
/* use acf as temporary array */
for (j=0;j<nlags;j++) acf[j]=lag[j];
k=nlags-1;
for (j=0;j<nlags;j++) {
lag[k]=acf[j];
k--;
}
}
/* add lags to block array */
for (j=0; j<nlags; j++) block[j]+=lag[j];
} else {
/* just copy correlation functions into block */
for (j=0; j<nlags; j++) block[j]=lag[j];
}
/* write out data block checking IF number for summed mode */
if ( (sumifs && (i==1)) || (!sumifs) ) {
if (obits==32) {
if (swapout) for (j=0; j<nlags; j++) swap_float(&block[j]);
fwrite(block,sizeof(float),nlags,output);
} else if (obits==16) {
float2short(block,nlags,smin,smax,sblock);
if (swapout) for (j=0; j<nlags; j++) swap_short(&sblock[j]);
fwrite(sblock,sizeof(unsigned short),nlags,output);
} else if (obits==8) {
float2char(block,nlags,smin,smax,cblock);
fwrite(cblock,sizeof(unsigned char),nlags,output);
} else if (obits==4) {
float2four(block,nlags,smin,smax,cblock);
fwrite(cblock,sizeof(unsigned char),nlags/2,output);
} else {
sprintf(message,"cannot write %d bits in wapp2fb",obits);
error_message(message);
}
}
} /* end of zerolagdump if */
if (!sumifs) { /* reset block and zerolag if not summing */
zerolag=0.0;
for (j=0; j<nlags; j++) block[j]=0.0;
}
} /* end of IFstream if */
} /* end of loop over IFs */
} /* end of processing if */
/* increment dump counter and update logfile every 512 dumps */
idump++;
if (idump%512 == 0) {
if (!opened) {
/* open up logfile */
open_log("filterbank.monitor");
opened=1;
}
sprintf(message,"time:%.1fs",realtime);
update_log(message);
}
} /* end of main read loop*/
/* job done - free up remaining arrays */
free(dump);free(block);free(sblock);free(cblock);free(window);
#ifdef FFTW
fftw_destroy_plan(fftplan);
fftw_free(acf); fftw_free(lag);
#endif
#ifndef FFTW
free(acf); free(lag);
#endif
}
static void fillCineonMainHeader(LogImageFile *cineon, CineonMainHeader *header,
const char *filename, const char *creator)
{
time_t fileClock;
struct tm *fileTime;
int i;
memset(header, 0, sizeof(CineonMainHeader));
/* --- File header --- */
header->fileHeader.magic_num = swap_uint(CINEON_FILE_MAGIC, cineon->isMSB);
header->fileHeader.offset = swap_uint(cineon->element[0].dataOffset, cineon->isMSB);
header->fileHeader.gen_hdr_size = swap_uint(sizeof(CineonFileHeader) + sizeof(CineonImageHeader) +
sizeof(CineonOriginationHeader), cineon->isMSB);
header->fileHeader.ind_hdr_size = 0;
header->fileHeader.user_data_size = 0;
header->fileHeader.file_size = swap_uint(cineon->element[0].dataOffset + cineon->height * getRowLength(cineon->width, cineon->element[0]), cineon->isMSB);
strcpy(header->fileHeader.version, "v4.5");
strncpy(header->fileHeader.file_name, filename, 99);
header->fileHeader.file_name[99] = 0;
fileClock = time(NULL);
fileTime = localtime(&fileClock);
strftime(header->fileHeader.creation_date, 12, "%Y:%m:%d", fileTime);
strftime(header->fileHeader.creation_time, 12, "%H:%M:%S%Z", fileTime);
header->fileHeader.creation_time[11] = 0;
/* --- Image header --- */
header->imageHeader.orientation = 0;
header->imageHeader.elements_per_image = cineon->depth;
for (i = 0; i < 3; i++) {
header->imageHeader.element[i].descriptor1 = 0;
header->imageHeader.element[i].descriptor2 = i;
header->imageHeader.element[i].bits_per_sample = cineon->element[0].bitsPerSample;
header->imageHeader.element[i].pixels_per_line = swap_uint(cineon->width, cineon->isMSB);
header->imageHeader.element[i].lines_per_image = swap_uint(cineon->height, cineon->isMSB);
header->imageHeader.element[i].ref_low_data = swap_uint(cineon->element[0].refLowData, cineon->isMSB);
header->imageHeader.element[i].ref_low_quantity = swap_float(cineon->element[0].refLowQuantity, cineon->isMSB);
header->imageHeader.element[i].ref_high_data = swap_uint(cineon->element[0].refHighData, cineon->isMSB);
header->imageHeader.element[i].ref_high_quantity = swap_float(cineon->element[0].refHighQuantity, cineon->isMSB);
}
header->imageHeader.white_point_x = swap_float(0.0f, cineon->isMSB);
header->imageHeader.white_point_y = swap_float(0.0f, cineon->isMSB);
header->imageHeader.red_primary_x = swap_float(0.0f, cineon->isMSB);
header->imageHeader.red_primary_y = swap_float(0.0f, cineon->isMSB);
header->imageHeader.green_primary_x = swap_float(0.0f, cineon->isMSB);
header->imageHeader.green_primary_y = swap_float(0.0f, cineon->isMSB);
header->imageHeader.blue_primary_x = swap_float(0.0f, cineon->isMSB);
header->imageHeader.blue_primary_y = swap_float(0.0f, cineon->isMSB);
strncpy(header->imageHeader.label, creator, 199);
header->imageHeader.label[199] = 0;
header->imageHeader.interleave = 0;
header->imageHeader.data_sign = 0;
header->imageHeader.sense = 0;
header->imageHeader.line_padding = swap_uint(0, cineon->isMSB);
header->imageHeader.element_padding = swap_uint(0, cineon->isMSB);
switch (cineon->element[0].packing) {
case 0:
header->imageHeader.packing = 0;
break;
case 1:
header->imageHeader.packing = 5;
break;
case 2:
header->imageHeader.packing = 6;
break;
}
/* --- Origination header --- */
/* we leave it blank */
/* --- Film header --- */
/* we leave it blank */
}
