import os import time import unittest from uuid import UUID import numpy as np import pytest import laspy def flip_bit(x): return 1 * (x == 0) class LasReaderTestCase(unittest.TestCase): simple = os.path.join(os.path.dirname(__file__), "data", "simple.las") tempfile = "junk.las" def setUp(self): self.FileObject = laspy.read(self.simple) LasFile = self.FileObject self.X = list(LasFile.X) self.Y = list(LasFile.Y) self.Z = list(LasFile.Z) self.intensity = list(LasFile.intensity) self.flag_byte = list(LasFile.flag_byte) self.return_num = list(LasFile.return_num) self.num_returns = list(LasFile.num_returns) self.scan_dir_flag = list(LasFile.scan_dir_flag) self.edge_flight_line = list(LasFile.edge_flight_line) self.raw_classification = list(LasFile.raw_classification) self.classification = list(LasFile.classification) self.synthetic = list(LasFile.synthetic) self.key_point = list(LasFile.key_point) self.withheld = list(LasFile.withheld) self.scan_angle_rank = list(LasFile.scan_angle_rank) self.user_data = list(LasFile.user_data) self.pt_src_id = list(LasFile.pt_src_id) ## The following conditional code is redundant for ## simple.las, which of course has only one pt. format. ## Perhaps find several other files? if LasFile.header.point_format.id in (1, 2, 3, 4, 5): self.gps_time = list(LasFile.gps_time) if LasFile.header.point_format.id in (2, 3, 5): self.red = list(LasFile.red) self.green = list(LasFile.green) self.blue = list(LasFile.blue) if LasFile.header.point_format.id in (4, 5): self.wave_form_packet_Desc_index = list(LasFile.wave_packet_desc_index) self.byte_offset_to_waveform = list(LasFile.byte_offset_to_waveform) self.waveform_packet_size = list(LasFile.waveform_packet_size) self.return_point_waveform_loc = list(LasFile.return_point_waveform_loc) self.x_t = list(LasFile.x_t) self.y_t = list(LasFile.y_t) self.z_t = list(LasFile.z_t) self.p1 = LasFile.points[100] self.p2 = LasFile.points[976] self.idx1 = 100 self.idx2 = 976 def test_x(self): """Fetch and test X dimension""" self.assertEqual(self.p1.X, 63666106, self.X[self.idx1]) self.assertEqual(self.p2.X, 63714022, self.X[self.idx2]) def test_y(self): """Fetch and test Y dimension""" self.assertEqual(self.p1.Y, 84985413, self.Y[self.idx1]) self.assertEqual(self.p2.Y, 85318232, self.Y[self.idx2]) def test_z(self): """Fetch and test Z dimension""" self.assertEqual(self.p1.Z, 42490, self.Z[self.idx1]) self.assertEqual(self.p2.Z, 42306, self.Z[self.idx2]) def test_intensity(self): """Fetch and test intensity dimension""" self.assertEqual(self.p1.intensity, 233, self.intensity[self.idx1]) self.assertEqual(self.p2.intensity, 1, self.intensity[self.idx2]) def test_bit_flags(self): """Fetch and test the binary flags associated with flag_byte dimension""" self.assertEqual(self.p1.flag_byte, self.flag_byte[self.idx1]) self.assertEqual(self.p2.flag_byte, self.flag_byte[self.idx2]) self.assertEqual(self.p1.return_num, self.return_num[self.idx1], 1) self.assertEqual(self.p2.return_num, self.return_num[self.idx2], 2) self.assertEqual(self.p1.num_returns, self.num_returns[self.idx1], 1) self.assertEqual(self.p2.num_returns, self.num_returns[self.idx2], 2) self.assertEqual(self.p1.scan_dir_flag, self.scan_dir_flag[self.idx1], 0) self.assertEqual(self.p2.scan_dir_flag, self.scan_dir_flag[self.idx2], 1) self.assertEqual(self.p1.edge_flight_line, self.edge_flight_line[self.idx1], 0) self.assertEqual(self.p2.edge_flight_line, self.edge_flight_line[self.idx2], 0) def test_scan_angle_rank(self): """Fetch and test scan_angle_rank dimension""" self.assertEqual(self.p1.scan_angle_rank, 2, self.scan_angle_rank[self.idx1]) self.assertEqual(self.p2.scan_angle_rank, 12, self.scan_angle_rank[self.idx2]) def test_raw_classification(self): """Fetch and test the dimension of raw_classification bytes""" self.assertEqual( self.p1.raw_classification, 1, self.raw_classification[self.idx1] ) self.assertEqual( self.p2.raw_classification, 2, self.raw_classification[self.idx2] ) def test_ptstrcid(self): """Fetch and test pt_src_id dimension""" self.assertEqual(self.p1.pt_src_id, 7328, self.pt_src_id[self.idx1]) self.assertEqual(self.p2.pt_src_id, 7334, self.pt_src_id[self.idx2]) def test_GPSTime(self): """Fetch and test gps_time dimension""" self.assertTrue( self.p1.gps_time - 2 * 246504.221932 + self.gps_time[self.idx1] < 0.00001 ) self.assertTrue( self.p2.gps_time - 2 * 249774.658254 + self.gps_time[self.idx2] < 0.00001 ) def test_red(self): """Fetch and test red dimension""" self.assertEqual(self.p1.red, 92, self.red[self.idx1]) self.assertEqual(self.p2.red, 94, self.red[self.idx2]) def test_green(self): """Fetch and test green dimension""" self.assertEqual(self.p1.green, 100, self.green[self.idx1]) self.assertEqual(self.p2.green, 84, self.green[self.idx2]) def test_blue(self): """Fetch and test blue dimension""" self.assertEqual(self.p1.blue, 110, self.blue[self.idx1]) self.assertEqual(self.p2.blue, 94, self.blue[self.idx2]) class LasWriterTestCase(unittest.TestCase): simple = os.path.join(os.path.dirname(__file__), "data", "simple.las") tempfile = "writer.las" output_tempfile = "writer_output.las" def setUp(self): self.FileObject = laspy.read(self.simple) def test_x(self): """Writing and testing X dimenson""" X = self.FileObject.X + 1 self.FileObject.X = X X2 = self.FileObject.X self.assertTrue(np.all(X == X2)) scaled_x = self.FileObject.x self.FileObject.x = scaled_x self.assertTrue(np.all(scaled_x == self.FileObject.x)) def test_y(self): """Writing and testing Y dimension""" Y = self.FileObject.Y + 1 self.FileObject.Y = Y Y2 = self.FileObject.Y self.assertTrue(np.all(Y == Y2)) scaled_y = self.FileObject.y self.FileObject.y = scaled_y self.assertTrue(np.all(scaled_y == self.FileObject.y)) def test_z(self): """Writing and testing Z dimension""" Z = self.FileObject.Z + 1 self.FileObject.Z = Z Z2 = self.FileObject.Z self.assertTrue(np.all(Z == Z2)) scaled_z = self.FileObject.z self.FileObject.z = scaled_z self.assertTrue(np.all(scaled_z == self.FileObject.z)) def test_intensity(self): """Writing and testing intensity dimension""" i = self.FileObject.intensity + 1 self.FileObject.intensity = i i2 = self.FileObject.intensity self.assertTrue(np.all(i == i2)) def test_return_num(self): """Writing and testing return_num dimension""" rn = self.FileObject.return_num + 1 self.FileObject.return_num = rn rn2 = self.FileObject.return_num self.assertTrue(np.all(rn == rn2)) def test_overflow_return_num(self): """Testing overflow handling""" rn = np.array(self.FileObject.return_num, dtype=np.uint32) + 100000 with self.assertRaises(OverflowError): self.FileObject.return_num = rn def test_num_returns(self): """Writing and testing num_returns dimension""" nr = self.FileObject.num_returns + 1 self.FileObject.num_returns = nr nr2 = self.FileObject.num_returns self.assertTrue(np.all(nr == nr2)) def test_scan_dir_flag(self): """Writing and testing scan_dir_flag dimension""" sdf = np.array([flip_bit(x) for x in self.FileObject.scan_dir_flag]) self.FileObject.scan_dir_flag = sdf sdf2 = self.FileObject.scan_dir_flag self.assertTrue(np.all(sdf == sdf2)) def test_edge_flight_line(self): """Writing and testing edge_flight_line dimension""" efl = np.array([flip_bit(x) for x in self.FileObject.edge_flight_line]) self.FileObject.edge_flight_line = efl efl2 = self.FileObject.edge_flight_line self.assertTrue(np.all(efl == efl2)) def test_classification(self): """Writing and testing classification byte.""" c1 = self.FileObject.classification + 1 self.FileObject.classification = c1 c2 = self.FileObject.classification self.assertTrue(np.all(c1 == c2)) def test_synthetic(self): """Writing and testing synthetic""" s1 = flip_bit(self.FileObject.synthetic) self.FileObject.synthetic = s1 s2 = self.FileObject.synthetic self.assertTrue(np.all(s1 == s2)) def test_key_point(self): """Writing and testing key point""" k1 = flip_bit(self.FileObject.key_point) self.FileObject.key_point = k1 k2 = self.FileObject.key_point self.assertTrue(np.all(k1 == k2)) def test_withheld(self): """Writing and testing withheld""" w1 = flip_bit(self.FileObject.withheld) self.FileObject.withheld = w1 w2 = self.FileObject.withheld self.assertTrue(np.all(w1 == w2)) def test_scan_angle_rank(self): """Writing and testing scan angle rank""" ar1 = self.FileObject.scan_angle_rank ar1[ar1 >= 1] -= 1 self.FileObject.scan_angle_rank = ar1 ar2 = self.FileObject.scan_angle_rank self.assertTrue(np.all(ar1 == ar2)) def test_user_data(self): """Writing and testing user data""" ud1 = self.FileObject.user_data + 1 self.FileObject.user_data = ud1 ud2 = self.FileObject.user_data self.assertTrue(np.all(ud1 == ud2)) def test_pt_src_id(self): """Writing and testing point source id""" p1 = self.FileObject.user_data + 1 self.FileObject.user_data = p1 p2 = self.FileObject.user_data self.assertTrue(np.all(p1 == p2)) def test_gps_time(self): """Writing and testing gps time""" g1 = self.FileObject.gps_time + 1.0 self.FileObject.gps_time = g1 g2 = self.FileObject.gps_time self.assertTrue(np.all(g1 == g2)) def test_red(self): """Writing and testing red""" r1 = self.FileObject.red + 1 self.FileObject.red = r1 r2 = self.FileObject.red self.assertTrue(np.all(r1 == r2)) def test_green(self): """Writing and testing green""" g1 = self.FileObject.green + 1 self.FileObject.green = g1 g2 = self.FileObject.green self.assertTrue(np.all(g1 == g2)) def test_blue(self): """Writing and testing blue""" b1 = self.FileObject.blue + 1 self.FileObject.blue = b1 b2 = self.FileObject.blue self.assertTrue(np.all(b1 == b2)) # def test_vlr_defined_dimensions2(self): # """Testing VLR defined dimension API""" # File2 = File.File(self.output_tempfile, mode="w", header=self.FileObject.header) # File2.define_new_dimension("test_dimension", 5, "This is a test.") # File2.X = self.FileObject.X # self.assertTrue(File2.test_dimension[500] == 0) # File2.close(ignore_header_changes=True) def tearDown(self): self.FileObject.write(self.output_tempfile) really_remove(self.output_tempfile) class LasHeaderWriterTestCase(unittest.TestCase): simple = os.path.join(os.path.dirname(__file__), "data", "simple.las") simple14 = os.path.join(os.path.dirname(__file__), "data", "simple1_4.las") tempfile = os.path.abspath("headerwriter.las") tempfile2 = os.path.abspath("headerwriter2.las") def setUp(self): self.las = laspy.read(self.simple) def test_file_src(self): """Testing file_src""" f1 = self.las.header.file_source_id + 1 self.las.header.file_source_id = f1 f2 = self.las.header.file_source_id assert f1 == f2 @pytest.mark.skip(reason="API changed") def test_uuid(self): """Testing uuid""" guid = self.las.header.guid guid2 = self.las.header.project_id self.assertEqual(guid, guid2) newGuid = UUID(bytes=b"1" * 16) self.las.header.guid = newGuid newGuid2 = self.las.header.get_guid() self.assertEqual(newGuid, newGuid2) def test_versions(self): """Testing Versions""" assert self.las.header.version.major == 1 with self.assertRaises(AttributeError): self.las.header.version.major = 2 def test_system_id(self): """Testing System ID""" sys1 = self.las.header.system_identifier sys1 = "1234567891" + sys1[10:] self.las.header.system_identifier = sys1 sys2 = self.las.header.system_identifier assert sys1 == sys2 def test_software_id(self): """ "Testing Software ID""" s1 = self.las.header.generating_software s1 = "1234567" + s1[7:] self.las.header.generating_software = s1 s2 = self.las.header.generating_software assert s1 == s2 # with self.assertRaises(laspy.LaspyException): # self.las.header.generating_software = "123" # with self.assertRaises(laspy.LaspyException): # self.las.header.generating_software = "1" * 100 def test_date(self): """Testing Date""" d1 = self.las.header.creation_date assert d1 is None from datetime import datetime d2 = datetime(2007, 12, 10) self.las.header.creation_date = d2 d3 = self.las.header.creation_date self.assertEqual(d2, d3) def test_point_recs_by_return(self): """Testing point records by return""" r1 = self.las.header.number_of_points_by_return + 1 self.las.header.number_of_points_by_return = r1 r2 = self.las.header.number_of_points_by_return assert np.all(r1 == r2) def test_min_max_update(self): """Testing the update min/max function""" x = self.las.X x[0] = max(x) + 1 y = self.las.Y y[0] = max(y) + 1 z = self.las.Z z[0] = max(z) + 1 self.las.X = x self.las.Y = y self.las.Z = z self.las.update_header() file_max = self.las.header.maxs assert np.all(file_max == [self.las.x[0], self.las.y[0], self.las.z[0]]) def test_histogram(self): """Testing the update_histogram functon""" h1 = self.las.header.number_of_points_by_return self.las.update_header() h2 = self.las.header.number_of_points_by_return assert np.all(h1 == h2) def test_offset(self): """Testing offset""" o1 = self.las.header.offsets o1[0] += 1 self.las.header.offsets = o1 o2 = self.las.header.offsets assert np.all(o1 == o2) def test_scale(self): """Testing Scale""" s1 = self.las.header.scales s1[0] += 1 self.las.header.scales = s1 s2 = self.las.header.scales assert np.all(s1 == s2) class LasWriteModeTestCase(unittest.TestCase): simple = os.path.join(os.path.dirname(__file__), "data", "simple.las") tempfile = "write-mode.las" output_tempfile = "write-mode-output.las" def setUp(self): self.File1 = laspy.read(self.simple) def test_using_barebones_header(self): """Testing file creation using barebones header""" header = laspy.LasHeader() File2 = laspy.LasData(header) self.assertTrue(File2.header.version == "1.2") X = self.File1.X Y = self.File1.Y Z = self.File1.Z File2.X = X File2.Y = Y File2.Z = Z File2.write(self.output_tempfile) File2 = laspy.read(self.output_tempfile) self.assertTrue(np.all(X == File2.X)) self.assertTrue(np.all(Y == File2.Y)) self.assertTrue(np.all(Z == File2.Z)) def test_using_existing_header(self): """Test file creation using an existing header""" File2 = laspy.LasData(self.File1.header) X = self.File1.X Y = self.File1.Y Z = self.File1.Z File2.X = X File2.Y = Y File2.Z = Z File2.write(self.output_tempfile) File2 = laspy.read(self.output_tempfile) self.assertTrue(np.all(X == File2.X)) self.assertTrue(np.all(Y == File2.Y)) self.assertTrue(np.all(Z == File2.Z)) def tearDown(self): really_remove(self.output_tempfile) class LasV_13TestCase(unittest.TestCase): simple = os.path.join(os.path.dirname(__file__), "data", "simple1_3.las") output_tempfile = "v13-output.las" def setUp(self): self.File1 = laspy.read(self.simple) def test_glob_encode(self): """Testing v1.3 Global Encoding""" old = self.File1.header.global_encoding.gps_time_type assert old == laspy.header.GpsTimeType.WEEK_TIME self.File1.header.global_encoding.gps_time_type = ( laspy.header.GpsTimeType.STANDARD ) assert ( self.File1.header.global_encoding.gps_time_type == laspy.header.GpsTimeType.STANDARD ) self.File1.header.global_encoding.gps_time_type = ( laspy.header.GpsTimeType.WEEK_TIME ) assert ( self.File1.header.global_encoding.gps_time_type == laspy.header.GpsTimeType.WEEK_TIME ) File2 = laspy.LasData(self.File1.header) File2.write(self.output_tempfile) File2 = laspy.read(self.output_tempfile) self.assertEqual( self.File1.header.global_encoding.waveform_data_packets_internal, File2.header.global_encoding.waveform_data_packets_internal, ) self.assertEqual( self.File1.header.global_encoding.waveform_data_packets_external, File2.header.global_encoding.waveform_data_packets_external, ) self.assertEqual( self.File1.header.global_encoding.synthetic_return_numbers, File2.header.global_encoding.synthetic_return_numbers, ) def test_wave_packet_desc_index(self): """Testing wave_packet_desc_index.""" test1 = self.File1.wave_packet_desc_index File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points assert np.all(test1 == File2.wave_packet_desc_index) def test_byte_offset_to_waveform_data(self): """Testing byte_offset_to_waveform_data""" test1 = self.File1.byte_offset_to_waveform_data File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points assert np.all(test1 == File2.byte_offset_to_waveform_data) def test_waveform_packet_size(self): """Testing waveform_packet_size""" test1 = self.File1.waveform_packet_size File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points.copy() assert np.all(test1 == File2.waveform_packet_size) def test_return_point_waveform_loc(self): """Testing return_point_waveform_loc""" test1 = self.File1.return_point_waveform_loc File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points.copy() assert np.all(test1 == File2.return_point_waveform_loc) File2.return_point_waveform_loc += 1 assert np.all(test1 != File2.return_point_waveform_loc) def test_x_t(self): """Testing x_t""" test1 = self.File1.x_t File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points.copy() assert np.all(test1 == File2.x_t) File2.x_t += 1 assert np.all(test1 != File2.x_t) def test_y_t(self): """Testing y_t""" test1 = self.File1.y_t File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points.copy() np.all(test1 == File2.y_t) File2.y_t += 1 assert np.all(test1 != File2.y_t) def test_z_t(self): """Testing z_t""" test1 = self.File1.z_t File2 = laspy.LasData(self.File1.header) File2.points = self.File1.points.copy() np.all(test1 == File2.z_t) File2.z_t += 1 np.all(test1 != File2.z_t) def tearDown(self): really_remove(self.output_tempfile) class LasV_14TestCase(unittest.TestCase): simple = os.path.join(os.path.dirname(__file__), "data", "simple1_4.las") tempfile = "v14.las" output_tempfile = "v14-output.las" def setUp(self): self.File1 = laspy.read(self.simple) def test_glob_encode(self): """Testing v1.4 Global Encoding""" old = self.File1.header.global_encoding.gps_time_type assert old == laspy.header.GpsTimeType.WEEK_TIME self.File1.header.global_encoding.gps_time_type = ( laspy.header.GpsTimeType.STANDARD ) assert ( self.File1.header.global_encoding.gps_time_type == laspy.header.GpsTimeType.STANDARD ) File2 = laspy.LasData(self.File1.header) self.assertEqual( self.File1.header.global_encoding.waveform_data_packets_internal, File2.header.global_encoding.waveform_data_packets_internal, ) self.assertEqual( self.File1.header.global_encoding.waveform_data_packets_external, File2.header.global_encoding.waveform_data_packets_external, ) self.assertEqual( self.File1.header.global_encoding.synthetic_return_numbers, File2.header.global_encoding.synthetic_return_numbers, ) def test_glob_encode_bits(self): b1 = self.File1.header.global_encoding.gps_time_type b2 = self.File1.header.global_encoding.waveform_data_packets_internal b3 = self.File1.header.global_encoding.waveform_data_packets_external b4 = self.File1.header.global_encoding.synthetic_return_numbers b5 = self.File1.header.global_encoding.wkt bf1 = 1 - int(b1) bf2 = 1 - int(b2) bf3 = 1 - int(b3) bf4 = 1 - int(b4) bf5 = 1 - int(b5) self.File1.header.global_encoding.gps_time_type = bf1 self.File1.header.global_encoding.waveform_data_packets_internal = bf2 self.File1.header.global_encoding.waveform_data_packets_external = bf3 self.File1.header.global_encoding.synthetic_return_numbers = bf4 self.File1.header.global_encoding.wkt = bf5 assert self.File1.header.global_encoding.gps_time_type == bf1 assert self.File1.header.global_encoding.waveform_data_packets_internal == bf2 assert self.File1.header.global_encoding.waveform_data_packets_external == bf3 assert self.File1.header.global_encoding.synthetic_return_numbers == bf4 assert self.File1.header.global_encoding.wkt == bf5 def test_classification_variables(self): """Testing v1.4 classification support""" classification = self.File1.classification classification_flags = self.File1.classification_flags scanner_channel = self.File1.scanner_channel scan_dir_flag = self.File1.scan_dir_flag edge_flight_line = self.File1.edge_flight_line return_num = self.File1.return_num num_returns = self.File1.num_returns File2 = laspy.LasData(self.File1.header) File2.classification = classification File2.classification_flags = classification_flags File2.scan_dir_flag = scan_dir_flag File2.scanner_channel = scanner_channel File2.edge_flight_line = edge_flight_line File2.return_num = return_num File2.num_returns = num_returns File2.write(self.output_tempfile) File2 = laspy.read(self.output_tempfile) assert np.all(num_returns == File2.num_returns) assert np.all(return_num == File2.return_num) assert np.all(edge_flight_line == File2.edge_flight_line) assert np.all(scan_dir_flag == File2.scan_dir_flag) assert np.all(classification_flags == File2.classification_flags) assert np.all(classification == File2.classification) assert np.all(scanner_channel == File2.scanner_channel) def tearDown(self): really_remove(self.output_tempfile) def really_remove(path, max_=1): """ Hack for Windows when quickly creating and deleting files. os.remove can return when Windows still thinks the file exists. When trying to re-create the file with the same name, a PermissionError occurs. :param path: path to remove :param max_: max seconds to wait """ wait = 0.01 while os.path.exists(path): try: os.remove(path) except WindowsError: time.sleep(wait) max_ -= wait if max_ <= 0: break