ppf_visibility_c.c

read envisat and analyis sar data from NASA

   mask			= 0;
   aos_elevation	= 0.0;
   los_elevation	= 0.0;

   max_segments=MAX_SEGMENTS;
   min_duration = 0.0;

   n = 0;
   sprintf(msg[n++], "\n\nPV_STAVISTIME\n"); 
   pv_print_msg(&n, msg);
  
   status = pv_stavistime(orbit_event_file_t, &start_orbit, &stop_orbit, swath_file,
                    sta_id, sta_db_file, &mask, &aos_elevation, &los_elevation,
                    &max_segments, &min_duration, &number_segments,
                    bgn_orbit, bgn_second, bgn_microsec, end_orbit, end_second, end_microsec,
                    zdop_orbit, zdop_second, zdop_microsec, ierr_t);

   if (status != PV_OK)
      {
      func_id = PV_STAVISTIME_ID;
      pv_vector_msg(&func_id, ierr_t, &n, msg);
      pv_print_msg(&n, msg);
      }



   /* Calling pv_drsvistime */
   /* --------------------- */

   max_segments=MAX_SEGMENTS;
   strcpy(orbit_event_file_t, "");
   start_orbit=2950;
   stop_orbit=2970;
   longitude=16.4;
   min_duration=0.0;  /* In seconds, minimum duration of an occultation that can be computed */

   n = 0;
   sprintf(msg[n++], "\n\nPV_DRSVISTIME\n");     
   pv_print_msg(&n, msg);

   status= pv_drsvistime(orbit_event_file_t, &start_orbit, &stop_orbit,
                         &longitude,
                         &max_segments, &min_duration,
                         &number_segments,
                         bgn_orbit, bgn_second, bgn_microsec,
                         end_orbit, end_second, end_microsec,
                         ierr_t);

   /* example of handling of error codes - in this case to detect an error on input */
   if (status != PV_OK)
      {
      func_id = PV_DRSVISTIME_ID;
      pv_vector_msg(&func_id, ierr_t, &n, msg);
      pv_print_msg(&n, msg);

      pv_vector_code(&func_id, ierr_t, &n, code);
      for (k=0; k<n; k++)
         {
         if (code[k] == PV_CFI_DRSVISTIME_PV_DRSINPUTS_CHECK_ERR)
            {
            n = 0;
            sprintf(msg[n++], "\n*** This error means that input parameters are not correct.\n");     
            pv_print_msg(&n, msg);
            }
         }
      }


   /* Calling pv_zonevistime */
   /* --------------------- */
   strcpy(orbit_event_file_t, "");		   
   start_orbit 	= 2900;
   stop_orbit 	= 2950;

#ifndef PL_WINDOWS
   strcpy(swath_file, "../data/RA_2___501_.N1");
   strcpy(zone_id, "ZANA____");			
   strcpy (zone_db_file,
             "../data/MPL_STZ_DBTRGT19970515_120000_00000000_00000000_19950101_000000_20100101_000000.N1");
#else
   strcpy(swath_file, "..\\data\\RA_2___501_.N1");
   strcpy(zone_id, "ZANA____");			
   strcpy (zone_db_file,
             "..\\data\\MPL_STZ_DBTRGT19970515_120000_00000000_00000000_19950101_000000_20100101_000000.N1");
#endif

   projection 	= 0;			
   zone_num 	= 0;				/* To be able to introduce the zone identifications */
   /* In another cases "zone_num" could have a value different from 0, i.e. "zone_num=5" and then,   
     "zone_long" and "zone_lat" could be defined as follows:
	zone_long[0]	= 0.0;
	zone_long[1]	= 20.0;
	zone_long[2]	= 20.0;
	zone_long[3]	= 0.0;
	zone_long[4]	= 0.0;
	zone_lat[0]	= 0.0;
	zone_lat[1]	= 0.0;
	zone_lat[2]	= -20.0;
	zone_lat[3]	= -20.0;
	zone_lat[4]	= 0.0;     */

   max_segments=MAX_SEGMENTS;
   min_duration = 0.0;

   n = 0;
   sprintf(msg[n++], "\n\nPV_ZONEVISTIME\n");     
   pv_print_msg(&n, msg);
  
   status = pv_zonevistime(orbit_event_file_t, &start_orbit, &stop_orbit, swath_file, zone_id, zone_db_file, 
               &projection, &zone_num, zone_long, zone_lat, &zone_diam, &max_segments, &min_duration, 
               &number_segments, bgn_orbit, bgn_second, bgn_microsec, end_orbit, end_second, end_microsec,
               coverage, ierr_t);

   if (status != PV_OK)
      {
      func_id = PV_ZONEVISTIME_ID;
      pv_vector_msg(&func_id, ierr_t, &n, msg);
      pv_print_msg(&n, msg);
      }


/*--------------------------------------------
 *   TIME SEGMENTS MANIPULATION FUNCTIONS    *
 *-------------------------------------------*/

   /* Calling pv_time_segments_not */
   /* ---------------------------- */
   order_switch=PV_TIME_ORDER;
   orbit_type = PV_ORBIT_ABS;

   n = 0;
   sprintf(msg[n++], "\n\nPV_TIME_SEGMENTS_NOT\n");     
   pv_print_msg(&n, msg);

   /* not function using zone_vis_time output segments as input segments */
   status=pv_time_segments_not( orbit_event_file_t, 
                                &orbit_type,  &order_switch,
                                &number_segments,                                  /* input segments list */
                                bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                                end_orbit, end_second, end_microsec, end_cycle,
                                &num_out,                                          /* output segments list */
                                &bgn_orbit_res, &bgn_secs_res, &bgn_microsecs_res, &bgn_cycle_res,
                                &end_orbit_res, &end_secs_res, &end_microsecs_res, &end_cycle_res,
                                pv_not_ierr);
   if (status != PV_OK)
     {
       func_id = PV_TIME_SEGMENTS_NOT_ID;
       pv_vector_msg(&func_id, pv_not_ierr, &n, msg);
       pv_print_msg(&n, msg);
     }

   /* Calling pv_time_segments_or */
   /* ---------------------------- */
   n = 0;
   sprintf(msg[n++], "\n\nPV_TIME_SEGMENTS_OR\n");
   pv_print_msg(&n, msg);

   status=pv_time_segments_or (orbit_event_file_t, 
                               &orbit_type, &order_switch,
                               &number_segments,                                  /* input segments list 1*/
                               bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                               end_orbit, end_second, end_microsec, end_cycle,
                               &number_segments,                                  /* input segments list 2*/
                               bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                               end_orbit, end_second, end_microsec, end_cycle,
                               &num_out,                                          /* output segments list */
                               &bgn_orbit_res, &bgn_secs_res, &bgn_microsecs_res, &bgn_cycle_res,
                               &end_orbit_res, &end_secs_res, &end_microsecs_res, &end_cycle_res,
                               pv_or_ierr);

   if (status != PV_OK)
     {
       func_id = PV_TIME_SEGMENTS_OR_ID;
       pv_vector_msg(&func_id, pv_or_ierr, &n, msg);
       pv_print_msg(&n, msg);
     }

   /* Calling pv_time_segments_and */
   /* ---------------------------- */
   n = 0;
   sprintf(msg[n++], "\n\nPV_TIME_SEGMENTS_AND\n");
   pv_print_msg(&n, msg);

   status=pv_time_segments_and (orbit_event_file_t, 
                                &orbit_type, &order_switch,
                                &number_segments,                                  /* input segments list 1*/
                                bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                                end_orbit, end_second, end_microsec, end_cycle,
                                &number_segments,                                  /* input segments list 2*/
                                bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                                end_orbit, end_second, end_microsec, end_cycle,
                                &num_out,                                          /* output segments list */
                                &bgn_orbit_res, &bgn_secs_res, &bgn_microsecs_res, &bgn_cycle_res,
                                &end_orbit_res, &end_secs_res, &end_microsecs_res, &end_cycle_res,
                                pv_and_ierr);

   if (status != PV_OK)
     {
       func_id = PV_TIME_SEGMENTS_AND_ID;
       pv_vector_msg(&func_id, pv_and_ierr, &n, msg);
       pv_print_msg(&n, msg);
     }

   /* Calling pv_time_segments_sort: */
   /* ordering the previous vector by relative orbit */
   /* ---------------------------------------------- */
   n = 0;
   sprintf(msg[n++], "\n\nPV_TIME_SEGMENTS_SORT\n");
   pv_print_msg(&n, msg);

   order_criteria=PV_ORBIT_REL;
   status=pv_time_segments_sort(orbit_event_file_t, 
                                &orbit_type, &order_criteria,
                                &num_out,
                                bgn_orbit_res, bgn_secs_res, bgn_microsecs_res, bgn_cycle_res,
                                end_orbit_res, end_secs_res, end_microsecs_res, end_cycle_res,
                                pv_sort_ierr);

   if (status != PV_OK)
     {
       func_id = PV_TIME_SEGMENTS_SORT_ID;
       pv_vector_msg(&func_id, pv_sort_ierr, &n, msg);
       pv_print_msg(&n, msg);
     }


   /* Calling pv_time_segments_merge: */
   /* ------------------------------- */
   n = 0;
   sprintf(msg[n++], "\n\nPV_TIME_SEGMENTS_MERGE\n");
   pv_print_msg(&n, msg);

   orbit_type = PV_ORBIT_ABS;
   order_switch=PV_TIME_ORDER;
   
   status=pv_time_segments_merge (orbit_event_file_t, 
                                  &orbit_type, &order_switch,
                                  &number_segments,                     /* input segments list 1*/
                                  bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                                  end_orbit, end_second, end_microsec, end_cycle,
                                  &num_out,                             /* output segments list */
                                  &bgn_orbit_res, &bgn_secs_res, &bgn_microsecs_res, &bgn_cycle_res,
                                  &end_orbit_res, &end_secs_res, &end_microsecs_res, &end_cycle_res,
                                  pv_merge_ierr);

   if (status != PV_OK)
     {
       func_id = PV_TIME_SEGMENTS_MERGE_ID;
       pv_vector_msg(&func_id, pv_merge_ierr, &n, msg);
       pv_print_msg(&n, msg);
     }


   /* Calling pv_time_segments_delta: */
   /* ------------------------------- */
   n = 0;
   sprintf(msg[n++], "\n\nPV_TIME_SEGMENTS_DELTA\n");
   pv_print_msg(&n, msg);

/*
  operation= PV_ADD;
  delta_secs=10;
  delta_microsecs=123;
*/
   entry_delta= 10.123;
   exit_delta = 10.123;

   /* DELTA */
   status=pv_time_segments_delta ( orbit_event_file_t, 
                                   &orbit_type,
                                   &entry_delta, &exit_delta,
                                   &number_segments,                     /* input segments list */
                                   bgn_orbit, bgn_second, bgn_microsec, bgn_cycle,
                                   end_orbit, end_second, end_microsec, end_cycle,
                                   &num_out,                             /* output segments list */
                                   &bgn_orbit_res, &bgn_secs_res, &bgn_microsecs_res, &bgn_cycle_res,
                                   &end_orbit_res, &end_secs_res, &end_microsecs_res, &end_cycle_res,
                                   pv_delta_ierr);
   
   if (status != PV_OK)
     {
       func_id = PV_TIME_SEGMENTS_DELTA_ID;
       pv_vector_msg(&func_id, pv_delta_ierr, &n, msg);
       pv_print_msg(&n, msg);
     }
   
   /* Deallocate dynamic memory */
   
   free(bgn_orbit_res);
   free(bgn_secs_res);
   free(bgn_microsecs_res);
   free(bgn_cycle_res);
   
   free(end_orbit_res);
   free(end_secs_res);
   free(end_microsecs_res);
   free(end_cycle_res);

   /* Calling pv_orbitinfo */
   /* -------------------- */

    n = 0;
    sprintf(msg[n++], "\n\nPV_ORBITINFO\n");
    pv_print_msg(&n, msg);
#ifndef PL_WINDOWS
    strcpy(orbit_event_file_t, "../data/MPL_ORB_EVTEMM19970829_093100_00000000_00000000_19970101_000000_20991231_000000.N1");
#else
    strcpy(orbit_event_file_t, "..\\data\\MPL_ORB_EVTEMM19970829_093100_00000000_00000000_19970101_000000_20991231_000000.N1");
#endif
    mode = PV_ABS_INFO + PV_OSV_INFO;
    abs_orbit = 2950;
    status = pv_orbitinfo(&mode, orbit_event_file_t, &abs_orbit, &rel_orbit, &cycle, &phase, &repeat_cycle, &cycle_length, &phasing, &mlst, mjd_anx, pos_anx, vel_anx, xm_anx, ierr_orb);
    if (status != PV_OK)
       {
       func_id = PV_ORBITINFO_ID;
       pv_vector_msg(&func_id, ierr_orb, &n, msg);
       pv_print_msg(&n, msg);

       /* example of handling of error codes */
       pv_vector_code(&func_id, ierr_orb, &n, code);
       for (k=0; k<n; k++)
          {
          if (code[k] == PV_CFI_ORBITINFO_OEF_READ_ERR)
             {
             n = 0;
             sprintf(msg[n++], "\n*** This error means that the OEF/OSF was not read correctly.\n");
             pv_print_msg(&n, msg);
             }
          }

       if (status <= PV_ERR) return(status);
       }

   return(PV_OK);
}