Laspy ಜೊತೆಗೆ LAS ಡೇಟಾವನ್ನು ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಪೈಥಾನ್ನಲ್ಲಿ ದೊಡ್ಡ LAS ಅಥವಾ LAZ ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಸಮರ್ಥ ಸಂಸ್ಕರಣೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಅತ್ಯಗತ್ಯ. ಲಾಸ್ಪಿ, LAS ಡೇಟಾವನ್ನು ಓದಲು, ಬರೆಯಲು ಮತ್ತು ಬದಲಾಯಿಸಲು ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್, LAS ಹೆಡರ್ಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಸಂಪಾದಿಸುವಂತಹ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೇಟಾವನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ನೀಡುತ್ತದೆ.
ಈ ಉದಾಹರಣೆಯು a ನಿಂದ ಪ್ರತಿ ಹತ್ತನೇ ಬಿಂದುವನ್ನು ಹೊರತೆಗೆಯುವ ಮೂಲಕ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಹೇಗೆ ಕಡಿಮೆ ಮಾಡುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ ಸೋಮಾರಿ ಫೈಲ್ ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮರುಬಳಕೆ ಲಾಸ್ಹೆಡರ್. ಇದಕ್ಕೆ ಹೆಡರ್ಗಳು ಡೇಟಾದೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ, ವಿಶೇಷವಾಗಿ ವಿಭಿನ್ನ ಪಾಯಿಂಟ್ ಎಣಿಕೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ.
ಹೊಸದನ್ನು ಸ್ಥಾಪಿಸುವಾಗ ಲಾಸ್ಡೇಟಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಹೆಡರ್ನಿಂದ ಆಬ್ಜೆಕ್ಟ್, ಬಳಕೆದಾರರು ಆಗಾಗ್ಗೆ ಹೊಂದಿಕೆಯಾಗದ ರಚನೆಯ ಗಾತ್ರವನ್ನು ಎದುರಿಸುತ್ತಾರೆ. ಈ ಅಸಮಾನತೆಯು ತಲೆಬರಹದ ಕಾರಣದಿಂದಾಗಿ ಸಂಭವಿಸುತ್ತದೆ ಪಾಯಿಂಟ್_ಎಣಿಕೆ ಹೊಸ ಡೇಟಾದೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಂದಾಣಿಕೆಯಾಗದಿರಬಹುದು.
ಆಫ್ಸೆಟ್ಗಳು, ಮಾಪಕಗಳು ಮತ್ತು ಪಾಯಿಂಟ್_ಕೌಂಟ್ನಂತಹ ಹೆಡರ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾರ್ಪಡಿಸುವ ಅಗತ್ಯವಿದೆಯೇ ಅಥವಾ ಹೆಚ್ಚು ಸ್ವಯಂಚಾಲಿತ ಪರಿಹಾರವಿದೆಯೇ ಎಂಬುದನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು ಸವಾಲಾಗಿದೆ. ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಮಾಡುವಾಗ ಈ ಮೌಲ್ಯಗಳನ್ನು ಸರಿಯಾಗಿ ನವೀಕರಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಈ ಪೋಸ್ಟ್ ವಿವರಿಸುತ್ತದೆ ಲಾಸ್ಪಿ, ಪರಿಣಾಮಕಾರಿ ಪ್ರಕ್ರಿಯೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
| ಆಜ್ಞೆ | ಬಳಕೆಯ ಉದಾಹರಣೆ |
|---|---|
| laspy.read() | ಈ ಆಜ್ಞೆಯು LAS ಅಥವಾ LAZ ಫೈಲ್ ಅನ್ನು LasData ಆಬ್ಜೆಕ್ಟ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಇದು ಫೈಲ್ನಿಂದ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೇಟಾ ಮತ್ತು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ, ಪೈಥಾನ್ನಲ್ಲಿ ಮಾರ್ಪಾಡು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. |
| np.arange() | ನಿಯಮಿತ ಅಂತರದಲ್ಲಿ ಅಂತರವಿರುವ ಸೂಚ್ಯಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, np.arange(0, len(las.points), 10) ಲೋಡ್ ಮಾಡಲಾದ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೇಟಾದಿಂದ ಪ್ರತಿ 10 ನೇ ಪಾಯಿಂಟ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಇದು ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ಗೆ ಅವಶ್ಯಕವಾಗಿದೆ. |
| laspy.LasHeader() | ಈ ಆಜ್ಞೆಯು LAS ಮತ್ತು LAZ ಡೇಟಾಗಾಗಿ ಹೊಸ ಹೆಡರ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಹೆಡರ್ ಪಾಯಿಂಟ್ ಫಾರ್ಮ್ಯಾಟ್, ಆವೃತ್ತಿ, ಆಫ್ಸೆಟ್ಗಳು ಮತ್ತು ಮಾಪಕಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಪ್ರಮುಖ ಮೆಟಾಡೇಟಾವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ರಚಿಸುವಾಗ ಅಥವಾ ಸಂಪಾದಿಸುವಾಗ ನಿರ್ಣಾಯಕವಾಗಿರುತ್ತದೆ ಲಾಸ್ಡೇಟಾ. |
| header.offsets | ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೇಟಾಗೆ ಕನಿಷ್ಠ x, y ಮತ್ತು z ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ಗಾಗಿ ಉಲ್ಲೇಖ ಬಿಂದುವನ್ನು ಬದಲಾಯಿಸುವಲ್ಲಿ ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ನಂತರ ಸರಿಯಾದ ಡೇಟಾ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. |
| header.scales | ಪ್ರಮಾಣದ ಅಂಶಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ x, y ಮತ್ತು z ಮೌಲ್ಯಗಳ ನಿಖರತೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ನಂತರ, ಸ್ಕೇಲ್ ಅಂಶಗಳನ್ನು ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ಮತ್ತು ಮಾರ್ಪಡಿಸುವುದು ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. |
| copy() | ವಸ್ತುವಿನ ಆಳವಿಲ್ಲದ ನಕಲನ್ನು ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂಲ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ನಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಹೆಡರ್ ಅನ್ನು ವರ್ಗಾಯಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಹೊಸ ಡೇಟಾಸೆಟ್ಗೆ ಯಾವುದೇ ಬದಲಾವಣೆಗಳು ಮೂಲ ಡೇಟಾವನ್ನು ಹಾನಿಗೊಳಿಸುವುದಿಲ್ಲ ಎಂದು ಖಾತರಿಪಡಿಸುತ್ತದೆ. |
| downsampled_las.write() | ಈ ಆಜ್ಞೆಯು ನವೀಕರಿಸಿದ ಅಥವಾ ಹೊಸದಾಗಿ ರೂಪುಗೊಂಡದನ್ನು ಬರೆಯುವ ಮೂಲಕ ಹೊಸ LAS ಅಥವಾ LAZ ಫೈಲ್ನಂತೆ ಡೌನ್ಸ್ಯಾಂಪ್ಲ್ಡ್ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಅನ್ನು ಉಳಿಸುತ್ತದೆ ಲಾಸ್ಡೇಟಾ ಫೈಲ್ಗೆ ಆಬ್ಜೆಕ್ಟ್. |
| unittest.TestCase | ಇದು ಪೈಥಾನ್ನ ಯುನಿಟೆಸ್ಟ್ ಫ್ರೇಮ್ವರ್ಕ್ಗೆ ಅಡಿಪಾಯ ವರ್ಗವಾಗಿದೆ, ಇದನ್ನು ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳನ್ನು ರಚಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಲೇಖನವು ಸರಿಯಾದ ಪ್ರಮಾಣದ ಅಂಕಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸುವ ಮೂಲಕ ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದನ್ನು ಬಳಸುತ್ತದೆ. |
| self.assertEqual() | ಯುನಿಟ್ ಪರೀಕ್ಷೆಯು ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ ಮತ್ತು ಅವು ಸಮಾನವಾಗಿಲ್ಲದಿದ್ದರೆ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆಯಲ್ಲಿ, ಕೆಳಗಿಳಿದ ಬಿಂದುಗಳ ಸಂಖ್ಯೆಯು ಊಹಿಸಲಾದ ಸಂಖ್ಯೆಗೆ ಅನುಗುಣವಾಗಿರುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. |
ಲಾಸ್ಪಿಯೊಂದಿಗೆ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿನ ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಅನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ a LAZ ಫೈಲ್, ಇದು ದೊಡ್ಡ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅವಶ್ಯಕವಾಗಿದೆ. ಬಳಸಿ ಮೂಲ ಫೈಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಲೇಸ್ಪಿ.ರೀಡ್() ಕಾರ್ಯ, ನಾವು ಪಾಯಿಂಟ್ ಡೇಟಾ ಮತ್ತು ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಕುರಿತು ಮೆಟಾಡೇಟಾ ಹೊಂದಿರುವ ಹೆಡರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ತಂತ್ರವು ಪ್ರತಿ ಹತ್ತನೇ ಬಿಂದುವನ್ನು ಆರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ನಿರ್ಣಾಯಕ ಭೌಗೋಳಿಕ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಉಳಿಸಿಕೊಂಡು ಡೇಟಾಸೆಟ್ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಇದನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಲಾಗುತ್ತದೆ np.arange() ಸೂಚ್ಯಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಿರ್ಮಿಸಲು. ಅಂಕಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಿದ ನಂತರ, ಮೆಟಾಡೇಟಾದಲ್ಲಿ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮೂಲ ಫೈಲ್ನಿಂದ ಹೆಡರ್ ಅನ್ನು ನಕಲಿಸಿ ಪಾಯಿಂಟ್_ಫಾರ್ಮ್ಯಾಟ್ ಮತ್ತು ಆವೃತ್ತಿ.
ಆದಾಗ್ಯೂ, ಮೂಲ ಹೆಡರ್ನಲ್ಲಿನ ಅಂಕಗಳ ಸಂಖ್ಯೆಯು ಡೌನ್ಸ್ಯಾಂಪಲ್ ಮಾಡಿದ ಡೇಟಾಗೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದಾಗ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆ ಸಂಭವಿಸುತ್ತದೆ. ಇದನ್ನು ಸರಿಪಡಿಸಲು, ನಾವು ಬಳಸುತ್ತೇವೆ ನಕಲು () ಮೂಲ ಹೆಡರ್ನ ಆಳವಿಲ್ಲದ ನಕಲನ್ನು ಮಾಡಲು ಮತ್ತು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾರ್ಪಡಿಸಲು ಕಾರ್ಯ ಪಾಯಿಂಟ್_ಎಣಿಕೆ ಡೌನ್ಸ್ಯಾಂಪ್ಡ್ ಪಾಯಿಂಟ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸಲು ಕ್ಷೇತ್ರ. ಹೊಸ ಹೆಡರ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ, ಡೌನ್ಸ್ಯಾಂಪಲ್ ಮಾಡಿದ ಅಂಕಗಳನ್ನು ಹೊಸದಕ್ಕೆ ಹಂಚಲಾಗುತ್ತದೆ ಲಾಸ್ಡೇಟಾ ನಿಜವಾದ x, y ಮತ್ತು z ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೊಂದಿರುವ ವಸ್ತು. ಅಂತಿಮವಾಗಿ, ದಿ ಲಾಸ್ಡೇಟಾ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ LAZ ಫೈಲ್ ಆಗಿ ಉಳಿಸಲಾಗಿದೆ ಬರೆಯಿರಿ () ವಿಧಾನ. ದೊಡ್ಡ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ಗಳಿಂದ ಚಿಕ್ಕ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ಅಗತ್ಯವಿರುವ ಬಳಕೆದಾರರಿಗೆ ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ.
ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆಫ್ಸೆಟ್ಗಳನ್ನು ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಮೂಲಕ ಮೊದಲನೆಯದನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ. ಪಾಯಿಂಟ್ ಮೋಡಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ನಿಖರವಾದ ಆಫ್ಸೆಟ್ಗಳನ್ನು ಹೊಂದಿರುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಅವುಗಳು 3D ಜಾಗದಲ್ಲಿ ಡೇಟಾದ ಮೂಲವನ್ನು ಸೂಚಿಸುತ್ತವೆ. ದಿ header.offsets ಅಟ್ರಿಬ್ಯೂಟ್ ಅನ್ನು ಕನಿಷ್ಠ x, y ಮತ್ತು z ನಿರ್ದೇಶಾಂಕಗಳೊಂದಿಗೆ ಡೌನ್ಸ್ಯಾಂಪ್ಲ್ಡ್ ಪಾಯಿಂಟ್ಗಳಿಂದ ನವೀಕರಿಸಲಾಗಿದೆ. ಅಂತೆಯೇ, ಪಾಯಿಂಟ್ ಡೇಟಾದ ನಿಖರತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವ ಪ್ರಮಾಣದ ಅಂಶಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಂದಿಸಲಾಗಿದೆ ಹೆಡರ್.ಸ್ಕೇಲ್ಸ್ ಗುಣಲಕ್ಷಣ. ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದಲ್ಲದೆ, ಡೇಟಾವು ನಿಖರ ಮತ್ತು ಜೋಡಿಸಲ್ಪಟ್ಟಿದೆ ಎಂದು ಭರವಸೆ ನೀಡುತ್ತದೆ, ಇದು ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಗೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ.
ಅಂತಿಮವಾಗಿ, ಅಂತಿಮ ಸ್ಕ್ರಿಪ್ಟ್ ಪೈಥಾನ್ನೊಂದಿಗೆ ಘಟಕ ಪರೀಕ್ಷೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ ಏಕಪರೀಕ್ಷೆ ಚೌಕಟ್ಟು. ಈ ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ, ಡೌನ್ಸಾಂಪ್ಲ್ಡ್ ಪಾಯಿಂಟ್ ಎಣಿಕೆಯು ಊಹಿಸಲಾದ ಮೌಲ್ಯಕ್ಕೆ ಅನುಗುಣವಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಾ ಪ್ರಕರಣವು ನಿರ್ಧರಿಸುತ್ತದೆ. ಸಂದರ್ಭಗಳು ಮತ್ತು ಡೇಟಾಸೆಟ್ಗಳಲ್ಲಿ ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಕಾರ್ಯವಿಧಾನವು ಸ್ಥಿರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಪರೀಕ್ಷಾ ಪ್ರಕರಣವನ್ನು ಬಳಸಿಕೊಂಡು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಟೆಸ್ಟ್ಕೇಸ್ ವರ್ಗ, ಮತ್ತು ಹೋಲಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಡೆಸಲಾಗುತ್ತದೆ self.assertEqual() ವಿಧಾನ. ಕೆಲಸದ ಹರಿವಿನೊಳಗೆ ಪರೀಕ್ಷೆಯನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ದೊಡ್ಡ ಯೋಜನೆಗಳು ಅಥವಾ ಪೈಪ್ಲೈನ್ಗಳಿಗೆ ನಿಯೋಜಿಸುವ ಮೊದಲು ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಕಾರ್ಯವಿಧಾನವು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು. ಹಲವಾರು ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ಅಸಂಗತತೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಕೆದಾರರಿಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
Laspy ಬಳಸಿಕೊಂಡು LAZ ಫೈಲ್ಗಳನ್ನು ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಮಾಡುವುದು: ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವುದು
ಈ ವಿಧಾನವು ಹಳೆಯ LAZ ಫೈಲ್ನಿಂದ ಪ್ರತಿ ಹತ್ತನೇ ಪಾಯಿಂಟ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ಮತ್ತು ಹೊಸ ಡೇಟಾಸೆಟ್ಗಾಗಿ ಹೆಡರ್ ಬದಲಾವಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪೈಥಾನ್ ಮತ್ತು ಲ್ಯಾಸ್ಪಿ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ.
import laspyimport numpy as npfrom copy import copy# Load the existing LAZ filelas = laspy.read("input_file.laz")# Downsample by taking every 10th pointindices = np.arange(0, len(las.points), 10)downsampled_points = las.points[indices]# Copy the header and adjust the point countheader = copy(las.header)header.point_count = len(downsampled_points)# Create new LasData with downsampled pointsd_las = laspy.LasData(header)d_las.points = downsampled_points# Write to a new LAZ filed_las.write("downsampled_output.laz")
LAZ ಫೈಲ್ಗಳನ್ನು ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಮಾಡುವಾಗ ಆಫ್ಸೆಟ್ ಮತ್ತು ಸ್ಕೇಲ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು
ಪೈಥಾನ್ನ ಈ ಆವೃತ್ತಿಯು ಡೌನ್ಸ್ಯಾಂಪಲ್ಡ್ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ಆಫ್ಸೆಟ್ಗಳು ಮತ್ತು ಮಾಪಕಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.
import laspyimport numpy as np# Load the original LAZ filelas = laspy.read("input_file.laz")# Downsample by taking every 10th pointindices = np.arange(0, len(las.points), 10)downsampled_points = las.points[indices]# Create new header and adjust offsets/scalesheader = 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 filedownsampled_las = laspy.LasData(header)downsampled_las.points = downsampled_pointsdownsampled_las.write("downsampled_with_scales.laz")
ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ LAS/LAZ ಫೈಲ್ಗಳಿಗಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆ
ಈ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ಕಾರ್ಯವಿಧಾನವು ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯುನಿಟ್ ಪರೀಕ್ಷೆಯನ್ನು ಒಳಗೊಂಡಿದೆ.
import unittestimport laspyimport numpy as npclass 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 ಫೈಲ್ನಲ್ಲಿನ ಹೆಚ್ಚುವರಿ ಆಯಾಮಗಳ ಸಮಗ್ರತೆ. ಸಾಮಾನ್ಯ x, y, ಮತ್ತು z ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ತೀವ್ರತೆ ಅಥವಾ GPS ಸಮಯದಂತಹ ಮಾಹಿತಿಯನ್ನು ಹಿಡಿದಿಡಲು ಹೆಚ್ಚುವರಿ ಬೈಟ್ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಡೇಟಾಸೆಟ್ ಈ ಹೆಚ್ಚುವರಿ ಆಯಾಮಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಮಾಡುವಾಗ ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು. ಹೆಚ್ಚುವರಿ ಆಯಾಮಗಳಲ್ಲಿನ ಬಿಂದುಗಳ ಸಂಖ್ಯೆಯು ಪ್ರಾಥಮಿಕ ಡೇಟಾದಲ್ಲಿನ ಕಡಿಮೆ ಪಾಯಿಂಟ್ ಎಣಿಕೆಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ ಎಂದು ನೀವು ಖಾತರಿಪಡಿಸಬೇಕು. ದಿ add_extra_dim ರಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕತೆ ಮಂದವಾದ LAS ಹೆಡರ್ಗೆ ಕಸ್ಟಮ್ ಆಯಾಮಗಳ ಸೇರ್ಪಡೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ವೇಗದ ಆಪ್ಟಿಮೈಸೇಶನ್ ಪಾಯಿಂಟ್ ಮೋಡಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ಶಿರೋಲೇಖಕ್ಕೆ ಮಾನವನ ಟ್ವೀಕ್ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅಗತ್ಯವಿರುವಾಗ, ಸಮರ್ಥ ಸೂಚಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ ಮತ್ತು ರಚನೆಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು ನಿಶ್ಚೇಷ್ಟಿತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಗಣನೀಯವಾಗಿ ವೇಗಗೊಳಿಸಬಹುದು. ನ ಶಕ್ತಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನಿಶ್ಚೇಷ್ಟಿತ, ನೀವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ತ್ಯಾಗ ಮಾಡದೆಯೇ ಅಗಾಧವಾದ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ನಿರ್ವಹಿಸಬಹುದು. ದೊಡ್ಡ ಯೋಜನೆಗಳಿಗೆ ಪರಿಹಾರಗಳನ್ನು ವಿಸ್ತರಿಸಲು ಅಥವಾ ಬಹು LAZ ಫೈಲ್ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಪೈಪ್ಲೈನ್ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
ಲ್ಯಾಸ್ಪಿಯೊಂದಿಗೆ ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಕುರಿತು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು
- ಹೊಂದಿಕೆಯಾಗದ ಅರೇ ಆಯಾಮಗಳನ್ನು ನಾನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು LasData?
- ಇದನ್ನು ನಿವಾರಿಸಲು, ದಿ point_count ಹೆಡರ್ನಲ್ಲಿ ಡೌನ್ಸ್ಯಾಂಪಲ್ ಮಾಡಲಾದ ಡೇಟಾದಲ್ಲಿನ ಪಾಯಿಂಟ್ಗಳ ನಿಜವಾದ ಸಂಖ್ಯೆಗೆ ಅನುರೂಪವಾಗಿದೆ. ಅಗತ್ಯವಿರುವಂತೆ ಎಣಿಕೆಯನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಬದಲಾಯಿಸಿ.
- ನಾನು ಯಾವಾಗಲೂ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕೇ offsets ಮತ್ತು scales ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ನಂತರ?
- ಹೌದು, ಈ ಮೌಲ್ಯಗಳನ್ನು, ವಿಶೇಷವಾಗಿ ಬೃಹತ್ ಡೇಟಾಸೆಟ್ಗಳಿಗೆ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ಅವಶ್ಯಕ. ದಿ offsets ಹೊಸ ಕನಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ scales ಡೇಟಾ ನಿಖರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
- ಮಾಡಬಹುದು laspy LAS ಫೈಲ್ಗಳಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಆಯಾಮಗಳನ್ನು ನಿರ್ವಹಿಸುವುದೇ?
- ಹೌದು, ಬಳಸಿ ಹೆಚ್ಚಿನ ಆಯಾಮಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು add_extra_dim ವೈಶಿಷ್ಟ್ಯದಲ್ಲಿ LasHeader, ಇದು ತೀವ್ರತೆ ಅಥವಾ GPS ಸಮಯದಂತಹ ಕಸ್ಟಮ್ ಆಯಾಮಗಳನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
- ಆಗಿದೆ numpy ಜೊತೆಗೆ ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ಗೆ ಅಗತ್ಯವಿದೆ laspy?
- ಅಗತ್ಯವಾಗಿ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೂ, numpy ಸೂಚ್ಯಂಕಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಉತ್ಪಾದಿಸುವ ಮೂಲಕ ಮತ್ತು ವ್ಯೂಹಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವ ಮೂಲಕ ಬೃಹತ್ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುಕೂಲವಾಗುತ್ತದೆ.
- ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಾನು ಹೇಗೆ ವೇಗಗೊಳಿಸಬಹುದು?
- ಬಳಸಿ numpy ಅರೇ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸೂಚ್ಯಂಕ. ಬೃಹತ್ ಪಾಯಿಂಟ್ ಮೋಡಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
ಪರಿಣಾಮಕಾರಿ ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ಗಾಗಿ ಪ್ರಮುಖ ಟೇಕ್ಅವೇಗಳು
ಡೌನ್ಸಾಂಪ್ಲಿಂಗ್ ಮಾಡುವಾಗ ಆಯಾಮದ ಹೊಂದಾಣಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು LAZ ಜೊತೆ ಫೈಲ್ಗಳು ಮಂದವಾದ, ದಿ ಪಾಯಿಂಟ್_ಎಣಿಕೆ ಹೆಡರ್ನಲ್ಲಿ ಆಸ್ತಿಯನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸರಿಹೊಂದಿಸಬೇಕು. ಆಫ್ಸೆಟ್ಗಳು ಮತ್ತು ಮಾಪಕಗಳನ್ನು ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ತಾಜಾ ಡೇಟಾದ ಸರಿಯಾದ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.
ಹೆಡರ್ ಮಾರ್ಪಾಡುಗಳಂತಹ ಕೆಲವು ಘಟಕಗಳಿಗೆ ಹಸ್ತಚಾಲಿತ ಹಸ್ತಕ್ಷೇಪದ ಅಗತ್ಯವಿರುತ್ತದೆ, ಆದರೆ ಇತರವುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು ನಿಶ್ಚೇಷ್ಟಿತ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಬೃಹತ್ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ನಿರ್ವಹಿಸಲು. ಘಟಕ ಪರೀಕ್ಷೆಯು ನಿಮ್ಮ ಡೌನ್ಸ್ಯಾಂಪ್ಲಿಂಗ್ ವರ್ಕ್ಫ್ಲೋನ ದೃಢತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಇದು ನೈಜ ಸಂದರ್ಭಗಳಲ್ಲಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ.