def __init__(self):
Component.__init__(self)
self.width = None
self.wavelength = None
self.altitude = None
self.costMode = 0
self.earthRadius = 0
self.input = None
self.output = None
self.corrfile = None
self.corrLooks = None
self.defoMaxCycles = 1.2
self.initMethod = 1
self.initOnly = False
self.maxComponents = 32
self.rangeLooks = 1
self.azimuthLooks = 1
self.dumpConnectedComponents = True
self.minConnectedComponentFrac = 0.01
self.connectedComponentCostThreshold = 300
self.magnitude = None
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'INPUT': ['self.input', 'str', 'mandatory'],
'OUTPUT': ['self.output', 'str', 'mandatory'],
'WAVELENGTH': ['self.wavelength', 'float', 'mandatory'],
'ALTITUDE': ['self.altitude', 'float', 'mandatory'],
'COSTMODE': ['self.costMode', 'str', 'mandatory'],
'EARTHRADIUS': ['self.earthRadius', 'float', 'mandatory'],
'WIDTH': ['self.width', 'float', 'mandatory'],
'CORRELATION': ['self.correlation', 'str', 'optional']
}
def __init__(self):
Component.__init__(self)
self.image1 = None
self.image2 = None
self.imageOut = None
self.image1Accessor = None
self.image2Accessor = None
self.imageOutAccessor = None
self.imageOutName = ''
self.lineLength = None
self.fileLength = None
self.acOffset = 0
self.dnOffset = 0
self.dictionaryOfVariables = { \
'OUTPUT_IMAGE_NAME' : ['self.imageOutName', 'str','optional'], \
'AC_OFFSET' : ['self.acOffset', 'int','optional'], \
'DN_OFFSET' : ['self.dnOffset', 'int','optional'] \
}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
typePos = 2
for key, val in self.dictionaryOfVariables.items():
if val[typePos] == 'mandatory':
self.mandatoryVariables.append(key)
elif val[typePos] == 'optional':
self.optionalVariables.append(key)
else:
print('Error. Variable can only be optional or mandatory')
raise Exception
return
def __init__(self, family='', name='', a=1.0, e2=0.0, model="Unit Sphere"):
Component.__init__(self,
family if family else self.__class__.family,
name=name)
ellipsoid.Ellipsoid.__init__(self, a, e2, model=model)
Heritage.__init__(self)
return None
def __init__(self):
Component.__init__(self)
self.masterOrbit = None
self.slaveOrbit = None
self.masterFrame = None
self.slaveFrame = None
self.lookAngle = None
self.rangePixelSize = None
self.azimuthPixelSize = None
self.height = None
self.radius = None
self.startingRange1 = None
self.startingRange2 = None
self.hBaselineTop = None
self.hBaselineRate = None
self.hBaselineAcc = None
self.vBaselineTop = None
self.vBaselineRate = None
self.vBaselineAcc = None
self.pBaselineTop = None
self.pBaselineBottom = None
self.orbSlcAzimuthOffset = None
self.orbSlcRangeOffset = None
self.rangeOffset = None
self.phaseConst = -99999
self.logger = logging.getLogger('isce.mroipac.baseline')
self.createPorts()
# Satisfy the old Component
self.dictionaryOfOutputVariables = {}
self.dictionaryOfVariables = {}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
return None
def __init__(self):
Component.__init__(self)
self._leaderFile = None
self._imageFile = None
self._parFile = None
self.output = None
self.imageFile = None
self.leaderFile = None
#####Soecific doppler functions for RSAT1
self.doppler_ref_range = None
self.doppler_ref_azi = None
self.doppler_predict = None
self.doppler_DAR = None
self.doppler_coeff = None
self.frame = Frame()
self.frame.configure()
self.constants = {'polarization': 'HH', 'antennaLength': 15}
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'LEADERFILE': ['self._leaderFile', 'str', 'mandatory'],
'IMAGEFILE': ['self._imageFile', 'str', 'mandatory'],
'PARFILE': ['self._parFile', 'str', 'optional'],
'OUTPUT': ['self.output', 'str', 'optional']
}
def __init__(self):
Component.__init__(self)
self.lookInstance = None
self.rangeLook = None
self.azimuthLook = None
self.width = None
self.length = None
self.lookType = ''
self.inputImage = ''
self.outputImage = ''
self.dictionaryOfVariables = {'RANGE_LOOK' : ['self.rangeLook', 'int','mandatory'], \
'AZIMUTH_LOOK' : ['self.azimuthLook', 'int','mandatory'], \
'WIDTH' : ['self.width', 'int','mandatory'], \
'LENGTH' : ['self.length', 'int','optional'], \
'LOOK_TYPE' : ['self.lookType', 'str','mandatory'], \
'INPUT_IMAGE' : ['self.inputImage', 'str','mandatory'], \
'OUTPUT_IMAGE' : ['self.outputImage', 'str','mandatory']}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
typePos = 2
for key, val in self.dictionaryOfVariables.items():
if val[typePos] == 'mandatory':
self.mandatoryVariables.append(key)
elif val[typePos] == 'optional':
self.optionalVariables.append(key)
else:
print('Error. Variable can only be optional or mandatory')
raise Exception
return
def __init__(self):
Component.__init__(self)
self.inputWidth = None
self.inputLines = None
self.outputWidth = None
self.outputLines = None
self.radarWavelength = None
self.slantRangePixelSpacing = None
self.azimuthOffsetsPoly = None
self.azimuthOffsetsAccessor = None
self.rangeOffsetsPoly = None
self.rangeOffsetsAccessor = None
self.rangeCarrierPoly = None
self.rangeCarrierAccessor = None
self.azimuthCarrierPoly = None
self.azimuthCarrierAccessor = None
self.residualRangeImage = None
self.residualAzimuthImage = None
self.residualRangeAccessor = None
self.residualAzimuthAccessor = None
self.dopplerPoly = None
self.dopplerAccessor = None
self.isComplex = None
self.method = None
self.flatten = None
self.startingRange = None
self.referenceWavelength = None
self.referenceStartingRange = None
self.referenceSlantRangePixelSpacing = None
self.logger = logging.getLogger('isce.stdproc.resamp_slc')
offsetPort = Port(name='offsets', method=self.addOffsets)
slcPort = Port(name='slc', method=self.addSlc)
referencePort = Port(name='reference', method=self.addReferenceImage)
self._inputPorts.add(offsetPort)
self._inputPorts.add(slcPort)
self._inputPorts.add(referencePort)
self.dictionaryOfVariables = { \
'INPUT_WIDTH' : ['self.inputWidth', 'int','mandatory'], \
'INPUT_LINES' : ['self.inputLines', 'int','optional'], \
'OUTPUT_LINES' : ['self.outputLines', 'int', 'optional'], \
'OUTPUT_WIDTH' : ['self.outputWidth', 'int', 'optional'], \
'RADAR_WAVELENGTH' : ['self.radarWavelength', 'float','mandatory'], \
'SLANT_RANGE_PIXEL_SPACING' : ['self.slantRangePixelSpacing', 'float','mandatory'], \
}
self.dictionaryOfOutputVariables = {}
return
def __init__(self):
Component.__init__(self)
self.xml = None
self.tiff = None
self.output = None
self.product = _Product()
self.frame = Frame()
self.frame.configure()
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {'XML': ['self.xml','str','mandatory'],
'TIFF': ['self.tiff','str','mandatory'],
'OUTPUT': ['self.output','str','optional']}
def __init__(self):
Component.__init__(self)
self.xml = None
self.tiff = None
self.orbitFile = None
self.outdir=None
self.numberBursts = None
self.bursts = []
self._xml_root=None
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {'XML': ['self.xml','str','mandatory'],
'TIFF': ['self.tiff','str','mandatory'],
'PREFIX': ['self.prefix','str','optional']}
def __init__(self):
Component.__init__(self)
self.width = None
self.length = None
self.blockSize = 64
self.padSize = 9
self.numberPtsPartial = 3
self.threshold = 0.9
self.firstPixelAcross = 0
self.lastPixelAcross = None
self.firstLineDown = 0
self.lastLineDown = None
self.printFlag = True
self.inImage = None
self.outImage = None
def __init__(self):
Component.__init__(self)
self.xml = None
self.tiff = None
self.calibrationXml = None
self.noiseXml = None
self.manifest = None
self.noiseCorrectionApplied = False
self.betaLUT = None
self.noiseLUT = None
self.gr2srLUT = None
self._xml_root = None
def __init__(self):
Component.__init__(self)
self._leaderFile = None
self._imageFile = None
self.output = None
self.frame = Frame()
self.frame.configure()
self.constants = {'polarization': 'HH',
'antennaLength': 12}
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {'LEADERFILE': ['self._leaderFile','str','mandatory'],
'IMAGEFILE': ['self._imageFile','str','mandatory'],
'OUTPUT': ['self.output','str','optional']}
def __init__(self):
Component.__init__(self)
self.xml = None
self.tiff = None
self.orbitfile = None
self.output = None
self.frame = Frame()
self.frame.configure()
self._xml_root = None
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'XML': ['self.xml', 'str', 'mandatory'],
'TIFF': ['self.tiff', 'str', 'mandatory'],
'ORBITFILE': ['self.orbitfile', 'str', 'optional'],
'OUTPUT': ['self.output', 'str', 'optional']
}
def __init__(self):
Component.__init__(self)
self.xml = None
self.tiff = None
self.output = None
self.gdal_translate = None
self.frame = Frame()
self.frame.configure()
self._xml_root = None
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'XML': ['self.xml', 'str', 'mandatory'],
'TIFF': ['self.tiff', 'str', 'mandatory'],
'OUTPUT': ['self.output', 'str', 'optional'],
'GDAL_TRANSLATE': ['self.gdal_translate', 'str', 'optional']
}
def __init__(self):
Component.__init__(self)
self.accessorIn = None
self.accessorOut = None
self.length = None
self.firstLine = None
self.numberLines = None
self.flipFlag = None
self.scale = None
self.exponent = None
self.minLat = None
self.maxLat = None
self.minLon = None
self.maxLon = None
self.title = ''
self.kmlFilename = ''
self.description = ''
self.dictionaryOfVariables = { \
'LENGTH' : ['self.length', 'int','mandatory'], \
'FIRST_LINE' : ['self.firstLine', 'int','optional'], \
'NUMBER_LINES' : ['self.numberLines', 'int','optional'], \
'FLIP_FLAG' : ['self.flipFlag', 'int','optional'], \
'SCALE' : ['self.scale', 'float','optional'], \
'EXPONENT' : ['self.exponent', 'float','optional'], \
'MIN_LAT' : ['self.minLat', 'float','mandatory'], \
'MAX_LAT' : ['self.maxLat', 'float','mandatory'], \
'MIN_LON' : ['self.minLon', 'float','mandatory'], \
'MAX_LON' : ['self.maxLon', 'float','mandatory'], \
'TITLE' : ['self.title', 'str','optional'], \
'KLM_FILENAME' : ['self.klmFilename', 'str','optional'], \
'DESCRIPTION' : ['self.description', 'str','optional'], \
}
self.dictionaryOfOutputVariables = {}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
typePos = 2
for key , val in self.dictionaryOfVariables.items():
if val[typePos] == 'mandatory':
self.mandatoryVariables.append(key)
elif val[typePos] == 'optional':
self.optionalVariables.append(key)
else:
print('Error. Variable can only be optional or mandatory')
raise Exception
return
def __init__(self,family=None,name=None,latitude=None,longitude=None,heading=None,radiusOfCurvature=None):
"""
@param latitude: the latitude in degrees
@param longitude: the longitude in degrees
@param heading: the heading in degrees
@param radiusOfCurvature: the radius of curvature at the specified coordinates
"""
#Rember always init the Component class first since it will call the _parameter method
#and set all defaults.
Component.__init__(self,family if family else self.__class__.family, name=name)
self._latitude = latitude
self._longitude = longitude
self._height = None
self._heading = heading
self._radiusOfCurvature = radiusOfCurvature
Coordinate.__init__(self,latitude=latitude,longitude=longitude,height=0.0)
def __init__(self,latitude=None,longitude=None,heading=None,radiusOfCurvature=None):
"""
@param latitude: the latitude in degrees
@param longitude: the longitude in degrees
@param heading: the heading in degrees
@param radiusOfCurvature: the radius of curvature at the specified coordinates
"""
Component.__init__(self)
Coordinate.__init__(self,latitude=latitude,longitude=longitude,height=0.0)
self._heading = heading
self._radiusOfCurvature = radiusOfCurvature
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {'LATITUDE': ['_latitude','float','mandatory'],
'LONGITUDE': ['_longitude','float','mandatory'],
'HEIGHT': ['_height','float','mandatory'],
'RADIUS_OF_CURVATURE': ['_radiusOfCurvature','float','mandatory'],
'HEADING': ['_heading','float','mandatory']}
self.initOptionalAndMandatoryLists()
def __init__(self):
Component.__init__(self)
self.sensor = None
self.doppler = None
self.dopplerValues = None
self.frame = None
# Derived Values
self.spacecraftHeight = 0.0
self.heightDt = 0.0
self.velocity = 0.0
self.squint = 0.0
sensorPort = Port(name='sensor', method=self.addSensor)
dopplerPort = Port(name='doppler', method=self.addDoppler)
self._inputPorts.add(sensorPort)
self._inputPorts.add(dopplerPort)
self.logger = logging.getLogger("isce.make_raw")
return None
def __init__(self):
Component.__init__(self)
self.xml = None
self.tiff = None
self.orbitFile = None
self.auxFile = None
self.orbitDir = None
self.auxDir = None
self.lutSigmaXml = None
self.productXml = None
self.noiseXml = None
self.noiseCorrectionApplied = False
self.noiseLUT = None
#self.manifest = None
#self.IPFversion = None
self.slantRangeFile = None
self._xml_root = None
self.output = None
self.lutSigma = None
self.product = GRDProduct()
self.product.configure()
def __init__(self):
Component.__init__(self)
self.instrumentFile = None
self.imageryFile = None
self._imageryFileList = ''
self.orbitFile = None
self.output = None
self._instrumentFileData = None
self._imageryFileData = None
self.logger = logging.getLogger("isce.sensor.EnviSAT")
self.frame = None
self.frameList = []
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'ORBITFILE': ['self.orbitFile', 'str', 'mandatory'],
'INSTRUMENTFILE': ['self.instrumentFile', 'str', 'mandatory'],
'IMAGEFILE': ['self._imageryFileList', 'str', 'mandatory'],
'OUTPUT': ['self.output', 'str', 'optional']
}
self.constants = {'antennaLength': 10.0, 'iBias': 128, 'qBias': 128}
def __init__(self):
Component.__init__(self)
self._leaderFile = None
self._imageFileList = ''
self._leaderFileList = ''
self._imageFile = None
self._orbitDir = None # Use this for Delft Orbit files
self._orbitFile = None # Use this for PDS Orbit files for now
self._orbitType = None
self.frameList = []
self.output = None
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'ORBIT_TYPE': ['self._orbitType','str','mandatory'],
'ORBIT_DIRECTORY': ['self._orbitDir','str','optional'],
'ORBIT_FILE': ['self._orbitFile','str','optional'],
'LEADERFILE': ['self._leaderFileList','str','mandatory'],
'IMAGEFILE': ['self._imageFileList','str','mandatory'],
'OUTPUT': ['self.output','str','optional']}
self.frame = Frame()
self.frame.configure()
# Constants are from
# J. J. Mohr and S. N. Madsen. Geometric calibration of ERS satellite
# SAR images. IEEE T. Geosci. Remote, 39(4):842-850, Apr. 2001.
self.constants = {'polarization': 'VV',
'antennaLength': 10,
'lookDirection': 'RIGHT',
'chirpPulseBandwidth': 15.50829e6,
'rangeSamplingRate': 18.962468e6,
'delayTime':6.622e-6,
'iBias': 15.5,
'qBias': 15.5}
return None
def __init__(self):
Component.__init__(self)
# mandatory input variables
self.dopplerCentroidCoefficients1 = []
self.dopplerCentroidCoefficients2 = []
self.prf1 = None
self.prf2 = None
self.squint1 = None
self.squint2 = None
self.antennaLength = None
self.velocity = None
self.slAzimuthResolution = None
self.dictionaryOfVariables = {'DOPPLER_CENTROID_COEFFICIENTS1':['self.dopplerCentroidCoefficients1', 'float','mandatory'], \
'DOPPLER_CENTROID_COEFFICIENTS2':['self.dopplerCentroidCoefficients2', 'float','mandatory'], \
'PRF1':['self.prf1', 'float','mandatory'], \
'PRF2':['self.prf2', 'float','mandatory'], \
'SQUINT1':['self.squint1', 'float','mandatory'], \
'SQUINT2':['self.squint2', 'float','mandatory'], \
'ANTENNA_LENGTH':['self.antennaLength', 'float','mandatory'], \
'VELOCITY':['self.velocity', 'float','mandatory']}
self.mandatoryVariables = []
self.optionalVariables = []
typePos = 2
for key, val in self.dictionaryOfVariables.items():
if val[typePos] == 'mandatory':
self.mandatoryVariables.append(key)
elif val[typePos] == 'optional':
self.optionalVariables.append(key)
else:
print('Error. Variable can only be optional or mandatory')
raise Exception
return
def __init__(self):
Component.__init__(self)
self.rangeLook = None
self.rangeLook = None
self.azimuthLook = None
self.phaseRange = None
self.phaseAzimuth = None
self.width = None
self.length = None
self.undefinedPixel = None
self.inEndianness = ''
self.outEndianness = ''
self.inputImage = ''
self.outputImage = ''
self.dictionaryOfVariables = {'RANGE_LOOK' : ['self.rangeLook', 'int','mandatory'], \
'AZIMUTH_LOOK' : ['self.azimuthLook', 'int','mandatory'], \
'WIDTH' : ['self.width', 'int','mandatory'], \
'UNDEFINED_PIXEL' : ['self.undefinedPixel', 'int','optional'], \
'LENGTH' : ['self.length', 'int','optional'], \
'INPUT_ENDIANNESS' : ['self.inEndianness', 'str','optional'], \
'OUTPUT_ENDIANNESS' : ['self.outEndianness', 'str','optional'], \
'INPUT_IMAGE' : ['self.inputImage', 'str','mandatory'], \
'OUTPUT_IMAGE' : ['self.outputImage', 'str','mandatory']}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
typePos = 2
for key, val in self.dictionaryOfVariables.items():
if val[typePos] == 'mandatory':
self.mandatoryVariables.append(key)
elif val[typePos] == 'optional':
self.optionalVariables.append(key)
else:
print('Error. Variable can only be optional or mandatory')
raise Exception
return
from iscesys.Component.Component import Component
from stdproc.alosreformat.ALOS_fbs2fbd.ALOS_fbs2fbdPy import ALOS_fbs2fbdPy
from stdproc.alosreformat.ALOS_fbd2fbs.ALOS_fbd2fbsPy import ALOS_fbd2fbsPy
from isceobj.Util.decorators import pickled, logged
from isceobj.Sensor import xmlPrefix
from isceobj.Util.decorators import use_api
# temporary comments: replaced a static dictionary with a class --convention
# precluded namedtuple (constants).
# Need to discuss how the _populate methods work.
# 2 state vectors?
LEADERFILE = Component.Parameter('_leaderFileList',
public_name='LEADERFILE',
default='',
container=list,
type=str,
mandatory=True,
doc="List of names of ALOS Leaderfile")
IMAGEFILE = Component.Parameter('_imageFileList',
public_name='IMAGEFILE',
default='',
container=list,
type=str,
mandatory=True,
doc="List of names of ALOS Imagefile")
RESAMPLE_FLAG = Component.Parameter('_resampleFlag',
public_name='RESAMPLE_FLAG',
default='',
from osgeo import gdal
from osgeo.gdalconst import *
import logging
import scipy.spatial as SS
import string
import random
from .phaseUnwrap import Vertex, Edge, PhaseUnwrap
from iscesys.Component.Component import Component
SOLVER = Component.Parameter('solver',
public_name='SOLVER',
default='pulp',
type=str,
mandatory=False,
intent='input',
doc='Linear Programming Solver')
REDUNDANT_ARCS = Component.Parameter('redArcs',
public_name='REDUNDANT_ARCS',
default=-1,
type=int,
mandatory=False,
intent='input',
doc='Redundant Arcs for Unwrapping')
INP_FILE = Component.Parameter('inpFile',
public_name='INPUT',
default=None,
import isceobj
from isceobj.Orbit.Orbit import StateVector
from isceobj.Planet.AstronomicalHandbook import Const
from isceobj.Planet.Planet import Planet
from isceobj.Scene.Frame import Frame
from iscesys.DateTimeUtil.DateTimeUtil import DateTimeUtil as DTUtil
from isceobj.Sensor import tkfunc, createAuxFile
from iscesys.Component.Component import Component
from .Sensor import Sensor
import numpy as np
HDF5 = Component.Parameter('hdf5FileList',
public_name='HDF5',
default=None,
container=list,
type=str,
mandatory=True,
intent='input',
doc='Single or list of hdf5 csk input file(s)')
class COSMO_SkyMed(Sensor):
"""
A class to parse COSMO-SkyMed metadata
"""
parameter_list = (HDF5, ) + Sensor.parameter_list
logging_name = "isce.sensor.COSMO_SkyMed"
family = 'cosmo_skymed'
def __init__(self, family='', name=''):
# installation and use of this software is restricted by a license agreement
# between the licensee and the california institute of technology. it is the
# user's responsibility to abide by the terms of the license agreement.
#
# Author: Giangi Sacco
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from iscesys.Component.Component import Component
import numpy as np
import os
import abc
from iscesys.Stitcher.Stitcher import Stitcher as ST
from iscesys.DataRetriever.DataRetriever import DataRetriever as DR
DTYPE = Component.Parameter('_dtype',
public_name='dtype',
default='',
type=str,
mandatory=True,
doc='Data type')
OUTPUT_FILE = Component.Parameter('_outputFile',
public_name='outputFile',
default='',
type=str,
mandatory=True,
doc='Output file.')
TILE_SIZE = Component.Parameter(
'_tileSize',
public_name='tileSize',
default=[],
container=list,
type=int,
mandatory=True,
# authority as may be required before exporting this software to any 'EAR99'
# embargoed foreign country or citizen of those countries.
#
# Author: Piyush Agram
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import datetime
import logging
import isceobj
from isceobj.Scene.Frame import Frame
from iscesys.Component.Component import Component
OUTPUT = Component.Parameter('output',
public_name='OUTPUT',
default='',
type=str,
mandatory=False,
intent='input',
doc='Raw output file name.')
class Sensor(Component):
"""
Base class for storing Sensor data
"""
parameter_list = (OUTPUT, )
logging_name = None
lookMap = {'RIGHT': -1, 'LEFT': 1}
family = 'sensor'
def __init__(self, family='', name=''):
#Author: Cunren Liang, 2015-
import isce
import datetime
import isceobj
import numpy as np
from iscesys.Component.Component import Component
from isceobj.Image.Image import Image
from isceobj.Orbit.Orbit import Orbit
from isceobj.Util.decorators import type_check
from iscesys.Traits import datetimeType
####List of parameters
SWATH_NUMBER = Component.Parameter('swathNumber',
public_name='swath number',
default=None,
type=int,
mandatory=True,
doc='swath number for bookkeeping')
POLARIZATION = Component.Parameter('polarization',
public_name='polarization',
default=None,
type=str,
mandatory=True,
doc='polarization')
NUMBER_OF_SAMPLES = Component.Parameter('numberOfSamples',
public_name='number of samples',
default=None,
type=int,
mandatory=True,
from isceobj.Planet.Planet import Planet
from isceobj.Orbit.Orbit import StateVector, Orbit
from isceobj.Orbit.OrbitExtender import OrbitExtender
from isceobj.Planet.AstronomicalHandbook import Const
from iscesys.Component.Component import Component
from iscesys.DateTimeUtil.DateTimeUtil import DateTimeUtil as DTUtil
from .GRDProduct import GRDProduct
import os
import glob
import json
import numpy as np
import shelve
SAFE = Component.Parameter('safe',
public_name='safe',
default=None,
type=str,
doc='SAFE folder with the GRD product')
POLARIZATION = Component.Parameter('polarization',
public_name='polarization',
default=None,
type=str,
doc='Polarization to unpack')
ORBIT_DIR = Component.Parameter('orbitDir',
public_name='orbit directory',
default=None,
type=str,
doc='Directory to search for orbit data')