ലാസ്പി ഉപയോഗിച്ച് ലാസ്/ലാസ് ഫയലുകൾ കാര്യക്ഷമമായി ഡൗൺസാംപ്ലിംഗ്: ഒരു ഘട്ടം ഘട്ടമായുള്ള ഗൈഡ്

ലാസ്പി ഉപയോഗിച്ച് LAS ഡാറ്റ ഡൗൺസാംപ്ലിംഗ് ചെയ്യുന്ന പ്രക്രിയ മനസ്സിലാക്കുന്നു

പൈത്തണിലെ വലിയ LAS അല്ലെങ്കിൽ LAZ ഫയലുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, കാര്യക്ഷമമായ പ്രോസസ്സിംഗിനും വിശകലനത്തിനും ഡൗൺസാംപ്ലിംഗ് അത്യാവശ്യമാണ്. ലാസ്പി, LAS ഡാറ്റ വായിക്കുന്നതിനും എഴുതുന്നതിനും മാറ്റുന്നതിനുമുള്ള ഒരു പൈത്തൺ പാക്കേജ്, LAS ഹെഡറുകൾ സൃഷ്ടിക്കുന്നതും എഡിറ്റുചെയ്യുന്നതും പോലുള്ള പോയിൻ്റ് ക്ലൗഡ് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനുള്ള നിരവധി മാർഗങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു.

എയിൽ നിന്ന് ഓരോ പത്താമത്തെ പോയിൻ്റും എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത് ഒരു ഡാറ്റാസെറ്റ് എങ്ങനെ കുറയ്ക്കാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു ലാസ് ഫയൽ ചെയ്ത് നിലവിലുള്ളത് വീണ്ടും ഉപയോഗിക്കുക ലാസ്ഹെഡർ. ഹെഡ്ഡറുകൾ ഡാറ്റയുമായി എങ്ങനെ ഇടപഴകുന്നു എന്നതിനെ കുറിച്ചുള്ള ഒരു ധാരണ ഇതിന് ആവശ്യമാണ്, പ്രത്യേകിച്ച് വ്യത്യസ്ത പോയിൻ്റ് കൗണ്ടുകളിൽ പ്രവർത്തിക്കുമ്പോൾ.

പുതിയത് സ്ഥാപിക്കുമ്പോൾ ലാസ്ഡാറ്റ നിലവിലുള്ള ഒരു തലക്കെട്ടിൽ നിന്നുള്ള ഒബ്‌ജക്‌റ്റ്, ഉപയോക്താക്കൾ പലപ്പോഴും പൊരുത്തപ്പെടാത്ത അറേ വലുപ്പം നേരിടുന്നു. തലക്കെട്ട് കാരണം ഈ അസമത്വം സംഭവിക്കുന്നു പോയിൻ്റ്_എണ്ണം പുതിയ ഡാറ്റയുമായി സ്വയമേവ വിന്യസിച്ചേക്കില്ല.

ഓഫ്‌സെറ്റുകൾ, സ്കെയിലുകൾ, പോയിൻ്റ്_കൌണ്ട് എന്നിവ പോലുള്ള ഹെഡർ ആട്രിബ്യൂട്ടുകൾ സ്വമേധയാ പരിഷ്‌ക്കരിക്കേണ്ടതുണ്ടോ അല്ലെങ്കിൽ കൂടുതൽ സ്വയമേവയുള്ള പരിഹാരമുണ്ടോ എന്ന് വിലയിരുത്തുക എന്നതാണ് വെല്ലുവിളി. ഉപയോഗിക്കുമ്പോൾ ഈ മൂല്യങ്ങൾ എങ്ങനെ ശരിയായി അപ്ഡേറ്റ് ചെയ്യാമെന്ന് ഈ പോസ്റ്റ് വിശദീകരിക്കുന്നു ലാസ്പി, ഫലപ്രദമായ ഒരു പ്രക്രിയയുടെ ഫലമായി.

ലാസ്പി ഉപയോഗിച്ച് പോയിൻ്റ് ക്ലൗഡ് ഡൗൺസാംപ്ലിംഗ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

ഈ പോസ്റ്റിലെ ആദ്യ സ്‌ക്രിപ്റ്റ് എ ഡൗൺസാംപ്ലിംഗിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു ലാസ് വലിയ പോയിൻ്റ് ക്ലൗഡ് ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ആവശ്യമായ ഫയൽ. ഉപയോഗിച്ച് യഥാർത്ഥ ഫയൽ ഇറക്കുമതി ചെയ്യുന്നതിലൂടെ lapy.read() ഫംഗ്‌ഷൻ, നമുക്ക് പോയിൻ്റ് ഡാറ്റയും പോയിൻ്റ് ക്ലൗഡിനെക്കുറിച്ചുള്ള മെറ്റാഡാറ്റ അടങ്ങുന്ന ഹെഡറും ആക്‌സസ് ചെയ്യാൻ കഴിയും. ഓരോ പത്താമത്തെ പോയിൻ്റും തിരഞ്ഞെടുക്കുന്നത് ഡൗൺസാംപ്ലിംഗ് ടെക്‌നിക്കിൽ ഉൾപ്പെടുന്നു, ഇത് നിർണായക ഭൂമിശാസ്ത്രപരമായ സവിശേഷതകൾ നിലനിർത്തിക്കൊണ്ട് ഡാറ്റാസെറ്റിൻ്റെ വലുപ്പം കുറയ്ക്കുന്നു. ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത് np.arange() സൂചികകളുടെ ഒരു നിര നിർമ്മിക്കാൻ. പോയിൻ്റുകൾ തിരഞ്ഞെടുത്ത ശേഷം, മെറ്റാഡാറ്റയിലെ അനുയോജ്യത ഉറപ്പാക്കാൻ യഥാർത്ഥ ഫയലിൽ നിന്ന് ഹെഡർ പകർത്തുക പോയിൻ്റ്_ഫോർമാറ്റ് പതിപ്പും.

എന്നിരുന്നാലും, ഒറിജിനൽ ഹെഡറിലെ പോയിൻ്റുകളുടെ എണ്ണം സാമ്പിൾ ചെയ്ത ഡാറ്റയുമായി പൊരുത്തപ്പെടാത്തപ്പോൾ ഒരു സാധാരണ പ്രശ്നം സംഭവിക്കുന്നു. ഇത് പരിഹരിക്കാൻ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു പകർത്തുക() ഒറിജിനൽ ഹെഡറിൻ്റെ ഒരു ആഴം കുറഞ്ഞ പകർപ്പ് ഉണ്ടാക്കുന്നതിനും സ്വമേധയാ പരിഷ്‌ക്കരിക്കുന്നതിനുമുള്ള പ്രവർത്തനം പോയിൻ്റ്_എണ്ണം സാമ്പിൾ ചെയ്ത പോയിൻ്റുകളുടെ എണ്ണം പ്രതിഫലിപ്പിക്കുന്നതിനുള്ള ഫീൽഡ്. പുതിയ തലക്കെട്ട് സൃഷ്‌ടിച്ച ശേഷം, സാമ്പിൾ ചെയ്‌ത പോയിൻ്റുകൾ പുതിയതിലേക്ക് അനുവദിക്കും ലാസ്ഡാറ്റ യഥാർത്ഥ x, y, z കോർഡിനേറ്റുകൾ അടങ്ങുന്ന ഒബ്ജക്റ്റ്. ഒടുവിൽ, ദി ലാസ്ഡാറ്റ ഉപയോഗിച്ച് ഒരു പുതിയ LAZ ഫയലായി സേവ് ചെയ്യുന്നു എഴുതുക() രീതി. വലിയ പോയിൻ്റ് ക്ലൗഡുകളിൽ നിന്ന് ചെറിയ ഡാറ്റാസെറ്റുകൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യേണ്ട ഉപയോക്താക്കൾക്ക് ഈ സ്‌ക്രിപ്റ്റ് കാര്യക്ഷമമാണ്.

സാമ്പിൾ ചെയ്യാത്ത ഡാറ്റയ്‌ക്കായി ഓഫ്‌സെറ്റുകളും സ്കെയിലുകളും സ്വയമേവ വീണ്ടും കണക്കാക്കി രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ആദ്യത്തേത് വിപുലീകരിക്കുന്നു. പോയിൻ്റ് ക്ലൗഡുകളുമായി പ്രവർത്തിക്കുമ്പോൾ, കൃത്യമായ ഓഫ്‌സെറ്റുകൾ ഉണ്ടായിരിക്കേണ്ടത് പ്രധാനമാണ്, കാരണം അവ 3D സ്‌പെയ്‌സിലെ ഡാറ്റയുടെ ഉത്ഭവത്തെ സൂചിപ്പിക്കുന്നു. ദി header.offsets ഡൗൺസാമ്പിൾ പോയിൻ്റുകളിൽ നിന്ന് ഏറ്റവും കുറഞ്ഞ x, y, z കോർഡിനേറ്റുകൾ ഉപയോഗിച്ച് ആട്രിബ്യൂട്ട് അപ്‌ഡേറ്റ് ചെയ്യുന്നു. അതുപോലെ, പോയിൻ്റ് ഡാറ്റയുടെ കൃത്യതയെ ബാധിക്കുന്ന സ്കെയിൽ ഘടകങ്ങൾ ഉപയോഗിച്ച് സജ്ജീകരിച്ചിരിക്കുന്നു തലക്കെട്ട്.സ്കെയിലുകൾ ആട്രിബ്യൂട്ട്. ഈ സ്ക്രിപ്റ്റ് പോയിൻ്റ് ക്ലൗഡിൻ്റെ വലുപ്പം കുറയ്ക്കുക മാത്രമല്ല, ഡാറ്റ കൃത്യവും വിന്യസിച്ചതുമാണെന്ന് ഉറപ്പുനൽകുന്നു, ഇത് പ്രായോഗിക ഉപയോഗത്തിന് കൂടുതൽ അനുയോജ്യമാക്കുന്നു.

അവസാനമായി, അന്തിമ സ്ക്രിപ്റ്റ് പൈത്തണിൻ്റെ യൂണിറ്റ് ടെസ്റ്റിംഗ് കാണിക്കുന്നു യൂണിറ്റ് ടെസ്റ്റ് ചട്ടക്കൂട്. ഈ സ്ക്രിപ്റ്റിൽ, ഒരു ടെസ്റ്റ് കേസ് ഡൗൺസാമ്പിൾ പോയിൻ്റ് കൗണ്ട് പ്രവചിച്ച മൂല്യവുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു. സന്ദർഭങ്ങളിലും ഡാറ്റാസെറ്റുകളിലും ഉടനീളം ഡൗൺസാംപ്ലിംഗ് നടപടിക്രമം സ്ഥിരമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിന് ഇത് നിർണായകമാണ്. ടെസ്റ്റ് കേസ് ഉപയോഗിച്ചാണ് നിർവചിച്ചിരിക്കുന്നത് ടെസ്റ്റ്കേസ് ക്ലാസ്, കൂടാതെ താരതമ്യം നടത്തുന്നത് ഉപയോഗിച്ചാണ് self.assertEqual() രീതി. വർക്ക്ഫ്ലോയിൽ പരിശോധന ഉൾപ്പെടുത്തുന്നതിലൂടെ, വലിയ പ്രോജക്ടുകളിലേക്കോ പൈപ്പ്ലൈനുകളിലേക്കോ വിന്യസിക്കുന്നതിന് മുമ്പ് ഡൗൺസാംപ്ലിംഗ് നടപടിക്രമം ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് ഞങ്ങൾക്ക് ഉറപ്പാക്കാനാകും. നിരവധി പോയിൻ്റ് ക്ലൗഡ് ഫയലുകളിൽ പ്രവർത്തിക്കുമ്പോൾ പ്രശ്നങ്ങളും പൊരുത്തക്കേടുകളും ഒഴിവാക്കാൻ ഈ സ്ക്രിപ്റ്റ് ഉപയോക്താക്കളെ സഹായിക്കുന്നു.

import laspy
import numpy as np
from copy import copy
# Load the existing LAZ file
las = laspy.read("input_file.laz")
# Downsample by taking every 10th point
indices = np.arange(0, len(las.points), 10)
downsampled_points = las.points[indices]
# Copy the header and adjust the point count
header = copy(las.header)
header.point_count = len(downsampled_points)
# Create new LasData with downsampled points
d_las = laspy.LasData(header)
d_las.points = downsampled_points
# Write to a new LAZ file
d_las.write("downsampled_output.laz")

import laspy
import numpy as np
# Load the original LAZ file
las = laspy.read("input_file.laz")
# Downsample by taking every 10th point
indices = np.arange(0, len(las.points), 10)
downsampled_points = las.points[indices]
# Create new header and adjust offsets/scales
header = laspy.LasHeader(point_format=las.header.point_format, version=las.header.version)
header.offsets = np.min([las.x[indices], las.y[indices], las.z[indices]], axis=1)
header.scales = np.array([0.01, 0.01, 0.01])  # Set new scales
# Create new LasData and write to file
downsampled_las = laspy.LasData(header)
downsampled_las.points = downsampled_points
downsampled_las.write("downsampled_with_scales.laz")

import unittest
import laspy
import numpy as np
class TestDownsampling(unittest.TestCase):
    def test_downsample_point_count(self):
        las = laspy.read("input_file.laz")
        indices = np.arange(0, len(las.points), 10)
        downsampled_points = las.points[indices]
        self.assertEqual(len(downsampled_points), len(indices))
if __name__ == "__main__":
    unittest.main()

LAS ഫയൽ മെറ്റാഡാറ്റയും അഡ്വാൻസ്ഡ് ഡൗൺസാംപ്ലിംഗ് ടെക്നിക്കുകളും കൈകാര്യം ചെയ്യുന്നു

വലിയ ഡാറ്റാസെറ്റുകളിൽ പ്രവർത്തിക്കുമ്പോൾ അലസമായ, യഥാർത്ഥ പോയിൻ്റ് ക്ലൗഡ് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതു പോലെ തന്നെ നിർണായകമാണ് മെറ്റാഡാറ്റ കൈകാര്യം ചെയ്യുന്നത്. യുടെ കൃത്യത നിലനിർത്തുന്നു ലാസ്ഹെഡർ ഡൗൺസാംപ്ലിംഗിനു ശേഷമുള്ള മൂല്യങ്ങൾ ഒരു പ്രധാന ബുദ്ധിമുട്ടാണ്. പോയിൻ്റ് ക്ലൗഡ് ഡാറ്റയുടെ കോർഡിനേറ്റുകൾ (x, y, z) മാറുന്നതിനാൽ, തലക്കെട്ട് ഈ മാറ്റങ്ങൾ പ്രതിഫലിപ്പിക്കണം. വീണ്ടും കണക്കാക്കുന്നു ഓഫ്സെറ്റുകൾ ഓരോ അളവുകൾക്കുമുള്ള ഏറ്റവും കുറഞ്ഞ മൂല്യങ്ങൾ വീണ്ടും കണക്കാക്കേണ്ടതുണ്ട്, അതേസമയം സ്കെയിലുകൾ പോയിൻ്റ് ഡാറ്റയുടെ കൃത്യത നിർണ്ണയിക്കുക, പ്രത്യേകിച്ച് സംഭരണത്തിനായി.

LAS ഫയലിലെ അധിക അളവുകളുടെ സമഗ്രതയാണ് വിലയിരുത്തേണ്ട മറ്റൊരു ഘടകം. തീവ്രത അല്ലെങ്കിൽ GPS സമയം പോലെയുള്ള സാധാരണ x, y, z കോർഡിനേറ്റുകൾ ഒഴികെയുള്ള വിവരങ്ങൾ സൂക്ഷിക്കാൻ അധിക ബൈറ്റുകൾ സാധാരണയായി ഉപയോഗിക്കുന്നു. ഡാറ്റാസെറ്റിൽ ഈ അധിക അളവുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, സാമ്പിൾ കുറയ്ക്കുമ്പോൾ അവ കൈകാര്യം ചെയ്യണം. അധിക അളവുകളിലെ പോയിൻ്റുകളുടെ എണ്ണം പ്രാഥമിക ഡാറ്റയിലെ കുറഞ്ഞ പോയിൻ്റ് എണ്ണവുമായി പൊരുത്തപ്പെടുന്നുവെന്ന് നിങ്ങൾ ഉറപ്പ് നൽകണം. ദി add_extra_dim പ്രവർത്തനക്ഷമത അലസമായ LAS ഹെഡറിലേക്ക് ഇഷ്‌ടാനുസൃത അളവുകൾ ചേർക്കുന്നത് പ്രവർത്തനക്ഷമമാക്കുന്നു.

അവസാനമായി, പോയിൻ്റ് മേഘങ്ങൾ കുറയ്ക്കുമ്പോൾ പരിഗണിക്കേണ്ട ഒരു പ്രധാന ഘടകമാണ് സ്പീഡ് ഒപ്റ്റിമൈസേഷൻ. തലക്കെട്ടിൽ മാനുഷികമായ മാറ്റങ്ങൾ സാധാരണയായി ആവശ്യമാണെങ്കിലും, കാര്യക്ഷമമായ ഇൻഡക്‌സിംഗ് പ്രയോജനപ്പെടുത്തി അറേ പ്രവർത്തനങ്ങൾ പ്രയോഗിച്ചുകൊണ്ട് പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യുന്നു നമ്പി പ്രക്രിയയെ ഗണ്യമായി ത്വരിതപ്പെടുത്താൻ കഴിയും. യുടെ ശക്തി പ്രയോജനപ്പെടുത്തി നമ്പി, പ്രകടനം ത്യജിക്കാതെ തന്നെ നിങ്ങൾക്ക് വലിയ ഡാറ്റാസെറ്റുകൾ വേഗത്തിൽ നിയന്ത്രിക്കാനാകും. ഒന്നിലധികം LAZ ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനായി വലിയ പ്രോജക്റ്റുകളിലേക്ക് പരിഹാരങ്ങൾ വിപുലീകരിക്കാനോ പൈപ്പ്ലൈനുകൾ ഓട്ടോമേറ്റ് ചെയ്യാനോ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.