Пример #1
0
def test_parse_pointer():
    # Example tests/mission_data/1p432690858esfc847p2111l2m1.img
    assert PDS3Image.parse_pointer(56, 640) == [35200, None]
    # Example tests/mission_data/W1782844276_1.LBL
    assert PDS3Image.parse_pointer(["W1782844276_1.IMG", 5], 1024) == [4096, 'W1782844276_1.IMG']
    # TODO: Awaiting other known valid examples to implement remaining conditions
    #print PDS3Image.parse_pointer("W1782844276_1.IMG", 1024)
    #print PDS3Image.parse_pointer(["W1782844276_1.IMG"], 1024)
    # ^IMAGE                         = 101337 <BYTES>
    assert PDS3Image.parse_pointer(Units(value=101337, units='BYTES'), None) == [101337, None]
Пример #2
0
def test_generate_pds_with_cahvor_right():
    generate_pds.PDSGenerator(filename_right)
    image = PDS3Image.open(os.path.splitext(filename_right)[0] + '.IMG')
    assert image.bands == 3
    assert image.lines == 2048
    assert image.samples == 3072
    assert image.format == 'BAND_SEQUENTIAL'
    assert image.dtype == numpy.dtype('>i2')

    # Testing .label
    assert image.label['^IMAGE'] == 2
    assert image.label['IMAGE']['SAMPLE_TYPE'] == 'MSB_INTEGER'
    assert image.label['IMAGE']['MAXIMUM'] == 167.0
    assert image.label['IMAGE']['MEDIAN'] == 15.0
    assert image.label['IMAGE']['MINIMUM'] == 0.0
    assert image.label['IMAGE']['SAMPLE_BITS'] == 16
    C = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_1']
    A = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_2']
    H = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_3']
    V = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_4']

    assert image.data.dtype == numpy.dtype('>i2')
    assert_almost_equal(C, [-1.4097, -0.7620000000000001, -3.3667])
    assert_almost_equal(A, [-0.0014849543217824793, 0.9944904168251026,
                            0.10481701080309513])
    assert_almost_equal(H, [-611.6639911280968, -23503.278833922475,
                            118.4987568245268])
    assert_almost_equal(V, [2443.2223036460596, -23181.3008195100119,
                            123.0602553862336])
    os.remove(os.path.splitext(filename_right)[0] + '.IMG')
Пример #3
0
def test_generate_pds_with_cahvor_left():
    generate_pds.PDSGenerator(filename_left)
    image = PDS3Image.open(os.path.splitext(filename_left)[0] + '.IMG')
    assert image.bands == 3
    assert image.lines == 1024
    assert image.samples == 1536
    assert image.format == 'BAND_SEQUENTIAL'
    assert image.dtype == numpy.dtype('>i2')

    # Testing .label
    assert image.label['^IMAGE'] == 2
    assert image.label['IMAGE']['SAMPLE_TYPE'] == 'MSB_INTEGER'
    assert image.label['IMAGE']['MAXIMUM'] == 174.0
    assert image.label['IMAGE']['MEDIAN'] == 14.0
    assert image.label['IMAGE']['MINIMUM'] == 0.0
    assert image.label['IMAGE']['SAMPLE_BITS'] == 16
    C = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_1']
    A = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_2']
    H = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_3']
    V = image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_4']

    assert image.data.dtype == numpy.dtype('>i2')
    assert_almost_equal(C, [1.4097, -0.7619999999999999, -3.3667])
    assert_almost_equal(A, [-0.07890237041579115, 0.9965459569473566,
                            -0.025895397943394106])
    assert_almost_equal(H, [-3668.464789238566, -23222.553666216594,
                            -218.30723379448355])
    assert_almost_equal(V, [-607.2642643405248, -23302.0994264739420,
                            24.0659112157058])
    os.remove(os.path.splitext(filename_left)[0] + '.IMG')
Пример #4
0
def test_pds3_1band_disk_format(pattern_data):
    image = PDS3Image(open(filename, 'rb'), memory_layout='DISK')

    assert image.data.shape == (1, 10, 10)
    assert image.data.size == 100

    assert_almost_equal(image.data[0], pattern_data)
Пример #5
0
def test_pds3_1band_image_format(pattern_data):
    image = PDS3Image.open(filename)

    assert image.data.shape == (10, 10)
    assert image.data.size == 100

    assert_almost_equal(image.data, pattern_data.reshape(10, 10))
Пример #6
0
 def create_image_set(self, filepaths):
     rgb = ['R', 'G', 'B']
     for filepath in filepaths:
         try:
             channels = []
             pds_image = PDS3Image.open(filepath)
             bands = pds_image.label['IMAGE']['BANDS']
             if bands == 3:
                 for n in range(bands):
                     name = os.path.basename(filepath) + '(%s)' % (rgb[n])
                     data = pds_image.image[:, :, n]
                     image = ImageStamp(
                         filepath=filepath, name=name, data_np=data,
                         pds_image=pds_image)
                     # self.file_dict[image.image_name] = image
                     channels.append(image)
                 self.images.append(channels)
             else:
                 name = os.path.basename(filepath)
                 data = pds_image.image
                 image = ImageStamp(
                     filepath=filepath, name=name, data_np=data,
                     pds_image=pds_image)
                 self.images.append([image])
                 # self.file_dict[image.image_name] = image
         except:
             warnings.warn(filepath + " cannnot be opened")
Пример #7
0
def test_image_stamp():
    """Test that ImageStamp sets correct attributes to pds compatible image"""
    pds_image = PDS3Image.open(FILE_1)
    test_image = pdsview.ImageStamp(FILE_1, FILE_1, pds_image, pds_image.data)
    assert test_image.file_name == FILE_1_NAME
    assert test_image.image_name == FILE_1
    assert 'PDS' in test_image.label[0]
    assert isinstance(test_image.label, list)
    assert not test_image.cuts
    assert not test_image.sarr
    assert not test_image.zoom
    assert not test_image.rotation
    assert not test_image.transforms
    assert test_image.not_been_displayed
Пример #8
0
def test_image_stamp():
    """Test that ImageStamp sets correct attributes to pds compatible image"""
    pds_image = PDS3Image.open(FILE_1)
    test_image = pdsview.ImageStamp(FILE_1, FILE_1, pds_image, pds_image.data)
    assert test_image.file_name == FILE_1_NAME
    assert test_image.image_name == FILE_1
    assert 'PDS' in test_image.label[0]
    assert isinstance(test_image.label, list)
    assert not test_image.cuts
    assert not test_image.sarr
    assert not test_image.zoom
    assert not test_image.rotation
    assert not test_image.transforms
    assert test_image.not_been_displayed
Пример #9
0
def test_pds3_1band_labels():
    image = PDS3Image.open(filename)

    assert image.filename == filename
    assert image.bands == 1
    assert image.lines == 10
    assert image.samples == 10
    assert image.format == 'BAND_SEQUENTIAL'
    assert image.pixel_type == numpy.dtype('>i2')
    assert image.dtype == numpy.dtype('>i2')
    assert image.start_byte == 640
    assert image.shape == (1, 10, 10)
    assert image.byte_order == '>'
    assert image.size == 100
Пример #10
0
 def __init__(self, filepath):
     pds_date = self._convert_date(filepath)
     print('pds_date:', pds_date)
     jpg_im = Image.open(filepath)
     np_ar = np.asarray(jpg_im)
     dim = np_ar.shape
     new_ar = np.zeros((dim[2], dim[0], dim[1]))
     new_ar[0, :, :] = np_ar[:, :, 0]
     new_ar[1, :, :] = np_ar[:, :, 1]
     new_ar[2, :, :] = np_ar[:, :, 2]
     new_ar = new_ar.astype('>i2')
     self.img = PDS3Image(new_ar)
     self.filename = os.path.splitext(filepath)[0]
     if self._label_file_exists():
         self.img.label = self._update_label(pds_date)
     self.img.save(self.filename + '.IMG')
Пример #11
0
 def __init__(self, filename, row, column, data_np=None, metadata=None,
              logger=None):
     BaseImage.__init__(self, data_np=data_np, metadata=metadata,
                        logger=logger)
     self.file_name = filename
     self.abspath = os.path.abspath(filename)
     self.basename = os.path.basename(filename)
     self.row = row
     self.column = column
     try:
         self.pds_image = PDS3Image.open(filename)
         self.set_data(self.pds_image.data)
         self.position = (row, column)
         self.size = (PSIZE, PSIZE)
         self.selected = False
         self.pds_compatible = True
     except:
         self.pds_compatible = False
Пример #12
0
def test_generate_pds_with_no_label():
    generate_pds.PDSGenerator(filename_nolabel)
    image = PDS3Image.open(os.path.splitext(filename_nolabel)[0] + '.IMG')
    assert image.bands == 3
    assert image.lines == 1024
    assert image.samples == 1536
    assert image.format == 'BAND_SEQUENTIAL'
    assert image.dtype == numpy.dtype('>i2')

    # Testing .label
    assert image.label['^IMAGE'] == 2
    assert image.label['IMAGE']['SAMPLE_TYPE'] == 'MSB_INTEGER'
    assert image.label['IMAGE']['MAXIMUM'] == 164.0
    assert image.label['IMAGE']['MEDIAN'] == 40.0
    assert image.label['IMAGE']['MINIMUM'] == 0.0
    assert image.label['IMAGE']['SAMPLE_BITS'] == 16

    with pytest.raises(KeyError):
        image.label['GEOMETRIC_CAMERA_MODEL']['MODEL_COMPONENT_1']

    os.remove(os.path.splitext(filename_nolabel)[0] + '.IMG')
Пример #13
0
 def __init__(self,
              filepath,
              metadata=None,
              logger=None,
              wavelength=float('nan'),
              unit='nm'):
     self.pds_image = PDS3Image.open(filepath)
     data = self.pds_image.image.astype(float)
     BaseImage.__init__(self,
                        data_np=data,
                        metadata=metadata,
                        logger=logger)
     self.set_data(data)
     self.image_name = os.path.basename(filepath)
     self.seen = False
     self.cuts = (None, None)
     self._check_acceptable_unit(unit)
     if np.isnan(wavelength):
         wavelength = get_wavelength(self.pds_image.label, unit)
     unit = astro_units.Unit(unit)
     self._wavelength = wavelength * unit
Пример #14
0
def preprocess_image(directory, name):
    url = 'https://pdsimage2.wr.usgs.gov/archive/mess-e_v_h-mdis-2-edr-rawdata-v1.0/MSGRMDS_1001/DATA/'+ str(directory)
    file = requests.get(url+ '/' + str(name))
    try: 
        img = open("img.txt", "wb+")
        img.write(file.content)
        image = PDS3Image.open('img.txt')
        t = image.image
        plt.imsave('images/'+ name +'.jpg', t, cmap = 'gray')

    except:
        img_data = bytearray()
        header = []
    #   print(file.content)

        # Test takes 2 values:
        # 0-> Before end of header is reached
        # 1-> End of header and start of image data
        test = 0
        for line in file.iter_lines():
            # Read Image data
            if test: 
                img_data.extend(line)

            # End of header is reached
            elif re.match("^END$", line.decode('utf-8').strip()):
                test = 1

            # Read the Header
            else:
                header.append(line.decode('utf-8').strip())

        file.close()
    #         print(header)
        # Flag takes 3 values:
        # 0-> before required data is encountered
        # 1-> Reading required data
        # 2-> after the required data is read
        flag = 0
        for line in header:
            
            if re.match('^TARGET_NAME',line):
                target = line.split('"')[1]
                # print(target)

            # Start Byte
            if re.match('^\^IMAGE',line):
                n = line.split('=')
                start_byte = int(n[1].strip())

            # End of required data 
            if re.match('^END_OBJECT',line):
                flag = 2

            # Beginning of required data
            if re.match('^OBJECT',line):
                flag = 1

            # Required data
            if flag == 1:
                if re.match('^LINES',line):
                    # Extract no of rows
                    a = line.split()
                    row = int(a[2])

                elif re.match('^LINE_SAMPLES',line):
                    # Extract no of columns
                    a = line.split()
                    column = int(a[2])

                elif re.match('^SAMPLE_BITS',line):
                    # Extract the type of bit encoding
                    a = line.split()
                    typ = 'uint'+ a[2]

        # print(row,column,typ)
        #     print(len(img_data.decode()))

        # b => bit width of data
        b = int(a[2])

        # Numpy array from byte array
        a = np.frombuffer(img_data[len(img_data)%16:],dtype=typ)
        #     print(a)

        # s => No of extra bits in the image data = Total no of bits - rows*columns
        s = (a.size/row -column)*row

        if s<0:
            print("Defective Image:",s)
            return None

        # t => Array after Trash data is removed
        t = a[int(s):].copy()
        # print(t.size)
        t.resize((row,column))

        # Reshaping the array
        np.divide(t,float(2**(b-8)))
        t = t.astype('uint8')

    # Save image
        plt.imsave('images/'+ name +'.jpg',t,cmap='gray')
#     plt.show()

    image = Image.open('images/' + name +'.jpg').convert("L")
    data = np.array(image)
    # print(data.shape)
    crmask,n_cosmic = lacosmic(data, contrast=5.0, cr_threshold=4.5, neighbor_threshold=0.3, 
                                    error=None, mask=None, background=None, effective_gain=1.0,
                                    readnoise=6.5, maxiter=1, border_mode=u'mirror')
    if (n_cosmic > 0):
        return data
    else:
        print("Cosmic Ray not found")