def is_a(file_name): """ Tests whether a given file_name corresponds to a Capella SAR file. Returns a reader instance, if so. Parameters ---------- file_name : str the file_name to check Returns ------- CapellaReader|None `CapellaReader` instance if Capella file, `None` otherwise """ if is_file_like(file_name): return None try: capella_details = CapellaDetails(file_name) logging.info( 'File {} is determined to be a Capella file.'.format(file_name)) return CapellaReader(capella_details) except SarpyIOError: return None
def open_complex(file_name: Union[str, BinaryIO]) -> SICDTypeReader: """ Given a file, try to find and return the appropriate reader object. Parameters ---------- file_name : str|BinaryIO Returns ------- SICDTypeReader Raises ------ SarpyIOError """ if (not is_file_like(file_name)) and (not os.path.exists(file_name)): raise SarpyIOError('File {} does not exist.'.format(file_name)) # parse openers, if not already done parse_openers() # see if we can find a reader though trial and error for opener in _openers: reader = opener(file_name) if reader is not None: return reader # check the final attempt openers for opener in _define_final_attempt_openers(): reader = opener(file_name) if reader is not None: return reader # If for loop completes, no matching file format was found. raise SarpyIOError('Unable to determine complex image format.')
def is_a(file_name): """ Tests whether a given file_name corresponds to a Cosmo Skymed file. Returns a reader instance, if so. Parameters ---------- file_name : str|BinaryIO the file_name to check Returns ------- CSKReader|None `CSKReader` instance if Cosmo Skymed file, `None` otherwise """ if is_file_like(file_name): return None if not is_hdf5(file_name): return None if h5py is None: return None try: csk_details = CSKDetails(file_name) logging.info('File {} is determined to be a Cosmo Skymed file.'.format( file_name)) return CSKReader(csk_details) except SarpyIOError: return None
def is_a(file_name): """ Tests whether a given file_name corresponds to a ICEYE file. Returns a reader instance, if so. Parameters ---------- file_name : str|BinaryIO the file_name to check Returns ------- CSKReader|None `CSKReader` instance if Cosmo Skymed file, `None` otherwise """ if h5py is None: return None if is_file_like(file_name): return None try: iceye_details = ICEYEDetails(file_name) logging.info( 'File {} is determined to be a ICEYE file.'.format(file_name)) return ICEYEReader(iceye_details) except (ImportError, IOError): return None
def is_a(file_name): """ Tests whether a given file_name corresponds to a NISAR file. Returns a reader instance, if so. Parameters ---------- file_name : str|BinaryIO the file_name to check Returns ------- NISARReader|None `NISARReader` instance if NISAR file, `None` otherwise """ if is_file_like(file_name): return None if not is_hdf5(file_name): return None if h5py is None: return None try: nisar_details = NISARDetails(file_name) logger.info('File {} is determined to be a NISAR file.'.format(file_name)) return NISARReader(nisar_details) except (ImportError, SarpyIOError): return None
def final_attempt(file_name: str) -> Optional[ComplexNITFReader]: """ Contingency check to open for some other complex NITF type file. Returns a reader instance, if so. Parameters ---------- file_name : str|BinaryIO the file_name to check Returns ------- ComplexNITFReader|None """ if is_file_like(file_name): return None try: nitf_details = ComplexNITFDetails(file_name) logger.info( 'File {} is determined to be some other format complex NITF.') return ComplexNITFReader(nitf_details) except (SarpyIOError, ValueError): return None
def is_a(file_name): """ Tests whether a given file_name corresponds to a SIO file. Returns a reader instance, if so. Parameters ---------- file_name : str the file_name to check Returns ------- SIOReader|None `SIOReader` instance if SIO file, `None` otherwise """ if is_file_like(file_name): return None try: sio_details = SIODetails(file_name) logging.info( 'File {} is determined to be a SIO file.'.format(file_name)) return SIOReader(sio_details) except IOError: return None
def is_a(file_name: str) -> Union[None, ICEYEReader]: """ Tests whether a given file_name corresponds to a ICEYE file. Returns a reader instance, if so. Parameters ---------- file_name : str|BinaryIO the file_name to check Returns ------- None|ICEYEReader `ICEYEReader` instance if ICEYE file, `None` otherwise """ if is_file_like(file_name): return None if not is_hdf5(file_name): return None if h5py is None: return None try: iceye_details = ICEYEDetails(file_name) logger.info( 'File {} is determined to be a ICEYE file.'.format(file_name)) return ICEYEReader(iceye_details) except SarpyIOError: return None
def __init__(self, nitf_details): """ Parameters ---------- nitf_details : str|BinaryIO|SIDDDetails filename, file-like object, or SIDDDetails object """ if isinstance(nitf_details, str) or is_file_like(nitf_details): nitf_details = SIDDDetails(nitf_details) if not isinstance(nitf_details, SIDDDetails): raise TypeError( 'The input argument for SIDDReader must be a filename or ' 'SIDDDetails object.') if not nitf_details.is_sidd: raise ValueError( 'The input file passed in appears to be a NITF 2.1 file that does not contain ' 'valid sidd metadata.') self._nitf_details = nitf_details SIDDTypeReader.__init__(self, self.nitf_details.sidd_meta, self.nitf_details.sicd_meta) NITFReader.__init__(self, nitf_details, reader_type="SIDD")
def __new__(cls, *args, **kwargs): if len(args) == 0: raise ValueError( 'The first argument of the constructor is required to be a file_path ' 'or CRSDDetails instance.') if is_file_like(args[0]): raise ValueError('File like object input not supported for CRSD reading at this time.') crsd_details = _validate_crsd_details(args[0]) if crsd_details.crsd_version.startswith('1.0'): return object.__new__(CRSDReader1_0) else: raise ValueError('Got unhandled CRSD version {}'.format(crsd_details.crsd_version))
def __init__(self, file_object): """ Parameters ---------- file_object : str|BinaryIO The path to or file like object referencing the CRSD file. """ self._crsd_version = None self._crsd_header = None self._crsd_meta = None self._close_after = False if isinstance(file_object, string_types): if not os.path.exists(file_object) or not os.path.isfile( file_object): raise SarpyIOError( 'path {} does not exist or is not a file'.format( file_object)) self._file_name = file_object self._file_object = open(file_object, 'rb') self._close_after = True elif is_file_like(file_object): self._file_object = file_object if hasattr(file_object, 'name') and isinstance( file_object.name, string_types): self._file_name = file_object.name else: self._file_name = '<file like object>' self._close_after = False else: raise TypeError('Got unsupported input type {}'.format( type(file_object))) self._file_object.seek(0, os.SEEK_SET) head_bytes = self._file_object.read(10) if not isinstance(head_bytes, bytes): raise ValueError('Input file like object not open in bytes mode.') if not head_bytes.startswith(b'CRSD'): raise SarpyIOError( 'File {} does not appear to be a CRSD file.'.format( self.file_name)) self._extract_version() self._extract_header() self._extract_crsd()
def __init__(self, nitf_details): """ Parameters ---------- nitf_details : : str|BinaryIO|SICDDetails filename, file-like object, or SICDDetails object """ if isinstance(nitf_details, string_types) or is_file_like(nitf_details): nitf_details = SICDDetails(nitf_details) if not isinstance(nitf_details, SICDDetails): raise TypeError( 'The input argument for SICDReader must be a filename, file-like object, ' 'or SICDDetails object.') super(SICDReader, self).__init__(nitf_details, reader_type="SICD")
def __init__(self, nitf_details): """ Parameters ---------- nitf_details : : str|BinaryIO|SICDDetails filename, file-like object, or SICDDetails object """ if isinstance(nitf_details, str) or is_file_like(nitf_details): nitf_details = SICDDetails(nitf_details) if not isinstance(nitf_details, SICDDetails): raise TypeError( 'The input argument for SICDReader must be a filename, file-like object, ' 'or SICDDetails object.') SICDTypeReader.__init__(self, None, nitf_details.sicd_meta) NITFReader.__init__(self, nitf_details, reader_type='SICD') self._check_sizes()
def __init__(self, file_object: Union[str, BinaryIO], sicd_meta: SICDType, user_data: Optional[Dict[str, str]] = None, check_older_version: bool = False, check_existence: bool = True): """ Parameters ---------- file_object : str|BinaryIO sicd_meta : SICDType user_data : None|Dict[str, str] check_older_version : bool Try to use an older version (1.1) of the SICD standard, for possible application compliance issues? check_existence : bool Should we check if the given file already exists, and raises an exception if so? """ self._data_written = True if isinstance(file_object, str): if check_existence and os.path.exists(file_object): raise SarpyIOError( 'Given file {} already exists, and a new SIO file cannot be created here.' .format(file_object)) file_object = open(file_object, 'wb') if not is_file_like(file_object): raise ValueError( 'file_object requires a file path or BinaryIO object') self._file_object = file_object if is_real_file(file_object): self._file_name = file_object.name self._in_memory = False else: self._file_name = None self._in_memory = True # choose magic number (with user data) and corresponding endian-ness magic_number = 0xFD7F02FF endian = SIODetails.ENDIAN[magic_number] # define basic image details raw_shape = (sicd_meta.ImageData.NumRows, sicd_meta.ImageData.NumCols, 2) pixel_type = sicd_meta.ImageData.PixelType if pixel_type == 'RE32F_IM32F': raw_dtype = numpy.dtype('{}f4'.format(endian)) element_type = 13 element_size = 8 format_function = ComplexFormatFunction(raw_dtype, order='MP', band_dimension=2) elif pixel_type == 'RE16I_IM16I': raw_dtype = numpy.dtype('{}i2'.format(endian)) element_type = 12 element_size = 4 format_function = ComplexFormatFunction(raw_dtype, order='MP', band_dimension=2) else: raw_dtype = numpy.dtype('{}u1'.format(endian)) element_type = 11 element_size = 2 format_function = ComplexFormatFunction( raw_dtype, order='MP', band_dimension=2, magnitude_lookup_table=sicd_meta.ImageData.AmpTable) # construct the sio header header = numpy.array([ magic_number, raw_shape[0], raw_shape[1], element_type, element_size ], dtype='>u4') # construct the user data - must be {str : str} if user_data is None: user_data = {} uh_args = sicd_meta.get_des_details(check_older_version) user_data['SICDMETA'] = sicd_meta.to_xml_string(tag='SICD', urn=uh_args['DESSHTN']) # write the initial things to the buffer self._file_object.seek(0, os.SEEK_SET) self._file_object.write(struct.pack('{}5I'.format(endian), *header)) # write the user data - name size, name, value size, value for name in user_data: name_bytes = name.encode('utf-8') self._file_object.write( struct.pack('{}I'.format(endian), len(name_bytes))) self._file_object.write( struct.pack('{}{}s'.format(endian, len(name_bytes)), name_bytes)) val_bytes = user_data[name].encode('utf-8') self._file_object.write( struct.pack('{}I'.format(endian), len(val_bytes))) self._file_object.write( struct.pack('{}{}s'.format(endian, len(val_bytes)), val_bytes)) self._data_offset = self._file_object.tell() # initialize the single data segment if self._in_memory: underlying_array = numpy.full(raw_shape, fill_value=0, dtype=raw_dtype) data_segment = NumpyArraySegment(underlying_array, 'complex64', raw_shape[:2], format_function=format_function, mode='w') self._data_written = False else: data_segment = NumpyMemmapSegment(self._file_object, self._data_offset, raw_dtype, raw_shape, 'complex64', raw_shape[:2], format_function=format_function, mode='w', close_file=False) self._data_written = True BaseWriter.__init__(self, data_segment)