void print_lasinfo(LASHeaderH LAS_header, LASSRSH LAS_srs)
{
char *las_srs_proj4 = LASSRS_GetProj4(LAS_srs);
int las_point_format = LASHeader_GetDataFormatId(LAS_header);
fprintf(stdout, "\nUsing LAS Library Version '%s'\n\n",
LAS_GetFullVersion());
fprintf(stdout, "LAS File Version: %d.%d\n",
LASHeader_GetVersionMajor(LAS_header),
LASHeader_GetVersionMinor(LAS_header));
fprintf(stdout, "System ID: '%s'\n",
LASHeader_GetSystemId(LAS_header));
fprintf(stdout, "Generating Software: '%s'\n",
LASHeader_GetSoftwareId(LAS_header));
fprintf(stdout, "File Creation Day/Year: %d/%d\n",
LASHeader_GetCreationDOY(LAS_header),
LASHeader_GetCreationYear(LAS_header));
fprintf(stdout, "Point Data Format: %d\n",
las_point_format);
fprintf(stdout, "Number of Point Records: %d\n",
LASHeader_GetPointRecordsCount(LAS_header));
fprintf(stdout, "Number of Points by Return: %d %d %d %d %d\n",
LASHeader_GetPointRecordsByReturnCount(LAS_header, 0),
LASHeader_GetPointRecordsByReturnCount(LAS_header, 1),
LASHeader_GetPointRecordsByReturnCount(LAS_header, 2),
LASHeader_GetPointRecordsByReturnCount(LAS_header, 3),
LASHeader_GetPointRecordsByReturnCount(LAS_header, 4));
fprintf(stdout, "Scale Factor X Y Z: %g %g %g\n",
LASHeader_GetScaleX(LAS_header),
LASHeader_GetScaleY(LAS_header), LASHeader_GetScaleZ(LAS_header));
fprintf(stdout, "Offset X Y Z: %g %g %g\n",
LASHeader_GetOffsetX(LAS_header),
LASHeader_GetOffsetY(LAS_header),
LASHeader_GetOffsetZ(LAS_header));
fprintf(stdout, "Min X Y Z: %g %g %g\n",
LASHeader_GetMinX(LAS_header),
LASHeader_GetMinY(LAS_header), LASHeader_GetMinZ(LAS_header));
fprintf(stdout, "Max X Y Z: %g %g %g\n",
LASHeader_GetMaxX(LAS_header),
LASHeader_GetMaxY(LAS_header), LASHeader_GetMaxZ(LAS_header));
if (las_srs_proj4 && strlen(las_srs_proj4) > 0) {
fprintf(stdout, "Spatial Reference:\n");
fprintf(stdout, "%s\n", las_srs_proj4);
}
else {
fprintf(stdout, "Spatial Reference: None\n");
}
fprintf(stdout, "\nData Fields:\n");
fprintf(stdout,
" 'X'\n 'Y'\n 'Z'\n 'Intensity'\n 'Return Number'\n");
fprintf(stdout, " 'Number of Returns'\n 'Scan Direction'\n");
fprintf(stdout,
" 'Flighline Edge'\n 'Classification'\n 'Scan Angle Rank'\n");
fprintf(stdout, " 'User Data'\n 'Point Source ID'\n");
if (las_point_format == 1 || las_point_format == 3 ||
las_point_format == 4 || las_point_format == 5) {
fprintf(stdout, " 'GPS Time'\n");
}
if (las_point_format == 2 || las_point_format == 3 ||
las_point_format == 5) {
fprintf(stdout, " 'Red'\n 'Green'\n 'Blue'\n");
}
fprintf(stdout, "\n");
fflush(stdout);
return;
}
/* ---------------------------------------------------------------------------------- */
void print_header(LASHeaderH header, int bSkipVLR) {
char *pszSignature = NULL;
char *pszProjectId = NULL;
char *pszSystemId = NULL;
char *pszSoftwareId = NULL;
/*char *pszProj4 = NULL;*/
char *pszVLRUser = NULL;
char *pszVLRDescription = NULL;
uint16_t nVLRLength = 0;
uint16_t nVLRRecordId = 0;
LASVLRH pVLR = NULL;
LASSRSH pSRS = NULL;
uint32_t nVLR = 0;
int i = 0;
#ifdef HAVE_GEOTIFF
const GTIF* pGTIF = NULL;
#else
const void* pGTIF = NULL;
#endif
pszSignature = LASHeader_GetFileSignature(header);
pszProjectId = LASHeader_GetProjectId(header);
pszSystemId = LASHeader_GetSystemId(header);
pszSoftwareId = LASHeader_GetSoftwareId(header);
pSRS = LASHeader_GetSRS(header);
/*pszProj4 = LASSRS_GetProj4(pSRS);*/
pGTIF = LASSRS_GetGTIF(pSRS);
nVLR = LASHeader_GetRecordsCount(header);
mexPrintf("\n---------------------------------------------------------\n");
mexPrintf(" Header Summary\n");
mexPrintf("---------------------------------------------------------\n");
if (strcmp(pszSignature,"LASF") !=0) {
LASError_Print("File signature is not 'LASF'... aborting");
return;
}
mexPrintf(" Version: %d.%d\n",
LASHeader_GetVersionMajor(header), LASHeader_GetVersionMinor(header));
mexPrintf(" Source ID: %d\n", LASHeader_GetFileSourceId(header) ) ;
mexPrintf(" Reserved: %d\n", LASHeader_GetReserved(header) );
mexPrintf(" Project ID/GUID: '%s'\n", pszProjectId);
mexPrintf(" System Identifier: '%s'\n", pszSystemId);
mexPrintf(" Generating Software: '%s'\n", pszSoftwareId);
mexPrintf(" File Creation Day/Year: %d/%d\n",
LASHeader_GetCreationDOY(header), LASHeader_GetCreationYear(header));
mexPrintf(" Header Size %d\n", LASHeader_GetHeaderSize(header));
mexPrintf(" Offset to Point Data %d\n", LASHeader_GetDataOffset(header));
mexPrintf(" Number Var. Length Records %d\n", LASHeader_GetRecordsCount(header));
mexPrintf(" Point Data Format %d\n", LASHeader_GetDataFormatId(header));
mexPrintf(" Point Data Record Length %d\n", LASHeader_GetDataRecordLength(header));
mexPrintf(" Number of Point Records %d\n", LASHeader_GetPointRecordsCount(header));
mexPrintf(" Number of Points by Return %d %d %d %d %d\n",
LASHeader_GetPointRecordsByReturnCount(header, 0),
LASHeader_GetPointRecordsByReturnCount(header, 1),
LASHeader_GetPointRecordsByReturnCount(header, 2),
LASHeader_GetPointRecordsByReturnCount(header, 3),
LASHeader_GetPointRecordsByReturnCount(header, 4));
mexPrintf(" Scale Factor X Y Z %.6g %.6g %.6g\n",
LASHeader_GetScaleX(header),
LASHeader_GetScaleY(header),
LASHeader_GetScaleZ(header));
mexPrintf(" Offset X Y Z %.6f %.6f %.6f\n",
LASHeader_GetOffsetX(header),
LASHeader_GetOffsetY(header),
LASHeader_GetOffsetZ(header));
mexPrintf(" Min X Y Z %.6f %.6f %.6f\n",
LASHeader_GetMinX(header),
LASHeader_GetMinY(header),
LASHeader_GetMinZ(header));
mexPrintf(" Max X Y Z %.6f %.6f %.6f\n",
LASHeader_GetMaxX(header),
LASHeader_GetMaxY(header),
LASHeader_GetMaxZ(header));
/*mexPrintf(" Spatial Reference %s\n", pszProj4);*/
#ifdef HAVE_LIBGEOTIFF
if (pGTIF) GTIFPrint((GTIF*)pGTIF, 0, 0);
#endif
if (nVLR && !bSkipVLR) {
mexPrintf("\n---------------------------------------------------------\n");
mexPrintf(" VLR Summary\n");
mexPrintf("---------------------------------------------------------\n");
for (i = 0; i < (int)nVLR; i++) {
pVLR = LASHeader_GetVLR(header, i);
if (LASError_GetLastErrorNum()) {
LASError_Print("Unable to fetch VLR");
return;
}
pszVLRUser = LASVLR_GetUserId(pVLR);
pszVLRDescription = LASVLR_GetDescription(pVLR);
nVLRLength = LASVLR_GetRecordLength(pVLR);
nVLRRecordId = LASVLR_GetRecordId(pVLR);
mexPrintf(" User: '******' - Description: '%s'\n", pszVLRUser, pszVLRDescription);
mexPrintf(" ID: %d Length: %d\n\n", nVLRRecordId, nVLRLength);
LASVLR_Destroy(pVLR);
pVLR = NULL;
LASString_Free(pszVLRUser);
LASString_Free(pszVLRDescription);
}
}
LASString_Free(pszSignature);
LASString_Free(pszProjectId);
LASString_Free(pszSystemId);
LASString_Free(pszSoftwareId);
/*LASString_Free(pszProj4);*/
}
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int verbose = FALSE, got_R = FALSE, scanC = FALSE, scanD = FALSE, get_BB_only = FALSE;
int i, argc = 0, n_arg_no_char = 0, classif = 0, intens = 0, nRet = 0, srcID = 0;
unsigned int nPoints;
char **argv, *fname = NULL, *parse_string = "xyz";
double *bbox, west, east, south, north, z_min = -1001, z_max, angle = 0;
LASReaderH reader = NULL;
LASHeaderH header = NULL;
LASPointH p = NULL;
if (nrhs == 0) {
mexPrintf ("usage: [xyz, bbox] = lasreader_mex ('filename', ['-A<ang>'], ['-C<class>'], ['-D<id>']\n");
mexPrintf (" [-I<intens>]', ['-N<return>'], ['-R<x_min/x_max/y_min/y_max[/z_min/z_max]>']);\n");
mexPrintf (" OR\n");
mexPrintf (" [class, bbox] = lasreader_mex ('filename', '-S'),\n\n");
mexPrintf (" OR\n");
mexPrintf (" [IDs, bbox] = lasreader_mex ('filename', '-D'),\n\n");
mexPrintf (" OR\n");
mexPrintf (" bbox = lasreader_mex ('filename', '-B'),\n\n");
mexPrintf ("First case usage:\n");
mexPrintf ("where xyz is 3xN array with the XYZ point coordinates:\n");
mexPrintf ("and bbox is a 1x6 vector with [xmin xmax ymin ymax zmin zmax]\n");
mexPrintf (" -A<ang> Clip out points with scan angle > ang\n");
mexPrintf (" -C<class> Retain only points with classification = class\n");
mexPrintf (" -D<id> Retain only points with Source IDs = id (DO NOT CONFUSE WITH -D)\n");
mexPrintf (" -D Scan file for a list of Source IDs (see below) (DO NOT CONFUSE WITH -D<id>).\n");
mexPrintf (" -I<intens> Clip out points with intensity < intens\n");
mexPrintf (" -N<return> Select first return (-N1) or last return (-N10)\n");
mexPrintf (" -R<x_min/x_max/y_min/y_max> - Clip to bounding box.\n");
mexPrintf (" Optionaly add z_min/z_max to make a 3D bounding box.\n\n");
mexPrintf (" -S Scan file for a list of Classifications (see below).\n");
mexPrintf (" -V Prints header contents info on ML shell.\n");
mexPrintf ("Second/Third cases:\n");
mexPrintf ("class|ID is a 1xN vector with a list of different classificatins|IDs\n");
mexPrintf ("present in file. No other data (except optional BBox) is return here.\n");
mexPrintf ("Fourth case:\n");
mexPrintf ("\tReturns only the bonding box 1x6 vector.\n");
return;
}
if (!mxIsChar(prhs[0])) mexErrMsgTxt ("First arg must contain the filename string.\n");
if (nlhs != 1 && get_BB_only) mexErrMsgTxt ("-B option implies one output only.\n");
fname = (char *) mxArrayToString (prhs[0]); /* Load the file name into a char string */
if (nrhs > 1) {
argc = nrhs;
for (i = 1; i < nrhs; i++) { /* Check input to find how many arguments are of type char */
if(!mxIsChar(prhs[i])) {
argc--;
n_arg_no_char++; /* Number of arguments that have a type other than char */
}
}
argc++; /* to account for the program's name to be inserted in argv[0] */
/* get the length of the input string */
argv = (char **)mxCalloc(argc, sizeof(char *));
argv[0] = "LASreader";
for (i = 1; i < argc; i++)
argv[i] = (char *)mxArrayToString(prhs[i+n_arg_no_char-1]);
}
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'A':
angle = atof(&argv[i][2]);
break;
case 'B':
get_BB_only = TRUE;
break;
case 'C':
classif = atoi(&argv[i][2]);
break;
case 'D':
if (argv[i][2])
srcID = atoi(&argv[i][2]);
else
scanD = TRUE;
break;
case 'I':
intens = atoi(&argv[i][2]);
break;
case 'N':
nRet = atoi(&argv[i][2]);
break;
case 'R':
if (decode_R (argv[i], &west, &east, &south, &north, &z_min, &z_max))
mexErrMsgTxt("Error decoding -R option!");
got_R = TRUE;
break;
case 'S':
scanC = TRUE;
break;
case 'V':
verbose = TRUE;
break;
}
}
}
reader = LASReader_Create(fname);
if (!reader) mexErrMsgTxt("LASREADER Error! Unable to read file!");
header = LASReader_GetHeader(reader);
if (!header) mexErrMsgTxt("LASREADER: Unable to fetch header for file");
if (get_BB_only && (scanC || scanD) )
mexPrintf("LASREADER WARNING: option -B takes precedence over -C or -D\n");
else if (scanC && scanD)
mexPrintf("LASREADER WARNING: option -C takes precedence over -D\n");
if (get_BB_only) {
plhs[0] = mxCreateDoubleMatrix(1, 6, mxREAL);
bbox = mxGetPr(plhs[0]);
bbox[0] = LASHeader_GetMinX(header); bbox[1] = LASHeader_GetMaxX(header);
bbox[2] = LASHeader_GetMinY(header); bbox[3] = LASHeader_GetMaxY(header);
bbox[4] = LASHeader_GetMinZ(header); bbox[5] = LASHeader_GetMaxZ(header);
return;
}
if (verbose) print_header(header, FALSE);
if (!(scanC || scanD)) {
if ((got_R + nRet + intens + classif + angle + srcID) == 0)
plain_xyz(plhs, reader, header);
else
conditional_xyz(plhs, reader, header, angle, classif, intens, nRet,
srcID, got_R, west, east, south, north, z_min, z_max);
}
else if (scanC) /* Scan file for a list of different classifications */
get_classification_list ( plhs, reader);
else if (scanD) /* Scan file for a list of different Source IDs */
get_ID_list ( plhs, reader);
if (nlhs == 2) {
plhs[1] = mxCreateDoubleMatrix(1, 6, mxREAL);
bbox = mxGetPr(plhs[1]);
bbox[0] = LASHeader_GetMinX(header); bbox[1] = LASHeader_GetMaxX(header);
bbox[2] = LASHeader_GetMinY(header); bbox[3] = LASHeader_GetMaxY(header);
bbox[4] = LASHeader_GetMinZ(header); bbox[5] = LASHeader_GetMaxZ(header);
}
LASReader_Destroy(reader);
LASHeader_Destroy(header);
return;
}
/* ---------------------------------------------------------------------------------- */
int conditional_xyz ( mxArray *plhs[], LASReaderH reader, LASHeaderH header,
double ang, int classif, int intens, int nRet, int srcID, int got_R,
double west, double east, double south, double north, double z_min, double z_max) {
/* Get the XYZ triplets that escape excluding clausules */
unsigned int n = 0, n_alloc = 100000, nPoints;
int got_Z = FALSE, first_only, last_only;
double *ptr, *tmp, x, y, z, MinZ, MaxZ;
LASPointH p = NULL;
last_only = (nRet > 9 ) ? TRUE : FALSE;
first_only = (nRet == 1 ) ? TRUE : FALSE;
if (z_min > -1000) {
got_Z = TRUE;
MinZ = LASHeader_GetMinZ(header);
MaxZ = LASHeader_GetMaxZ(header);
}
ptr = (double *)mxMalloc((mwSize)(n_alloc * 3 * sizeof(double)));
nPoints = LASHeader_GetPointRecordsCount(header);
p = LASReader_GetNextPoint(reader);
while (p) {
if (!LASPoint_IsValid(p)) {
p = LASReader_GetNextPoint(reader);
continue;
}
if (classif && LASPoint_GetClassification(p) != classif) goto fim;
if (srcID && LASPoint_GetPointSourceId(p) != srcID) goto fim;
if (intens && LASPoint_GetIntensity(p) < intens) goto fim;
if (last_only && LASPoint_GetReturnNumber(p) != LASPoint_GetNumberOfReturns(p)) goto fim;
if (first_only && LASPoint_GetReturnNumber(p) != 1) goto fim;
if (ang && (LASPoint_GetScanAngleRank(p) > ang || LASPoint_GetScanAngleRank(p) < -ang)) goto fim;
x = LASPoint_GetX(p); y = LASPoint_GetY(p);
if (got_R && (x < west || x > east || y < south || y > north)) goto fim;
z = LASPoint_GetZ(p);
if (got_Z && (z < MinZ || z > MaxZ)) goto fim;
ptr[n*3] = x;
ptr[n*3+1] = y;
ptr[n*3+2] = z;
n++;
if (n >= n_alloc) {
n_alloc += 50000;
ptr = mxRealloc((void *)ptr, (mwSize)(n_alloc * 3 * sizeof(double)));
}
fim:
p = LASReader_GetNextPoint(reader);
}
if (n) {
n--;
ptr = mxRealloc((void *)ptr, (mwSize)(n * 3 * sizeof(double)));
plhs[0] = mxCreateDoubleMatrix(3, 1, mxREAL);
tmp = mxGetPr(plhs[0]);
mxFree((void *)tmp);
mxSetPr(plhs[0], ptr);
mxSetN(plhs[0], (mwSize)n);
}
else
plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL); /* We got no points */
return (n);
}
int main(int argc, char *argv[])
{
int i = 0;
char* file_name = NULL;
LASReaderH reader = NULL;
LASHeaderH header = NULL;
LASWriterH writer = NULL;
int check_points = FALSE;
int repair_header = FALSE;
int change_header = FALSE;
int repair_bounding_box = FALSE;
int use_stdin = FALSE;
int update_return_counts = FALSE;
int skip_vlr = FALSE;
int wkt = FALSE;
char *system_identifier = NULL;
char *generating_software = NULL;
unsigned char file_creation_day = 0;
unsigned char file_creation_year = 0;
int err = 0;
LASPointSummary* summary = NULL;
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"--version") == 0)
{
char* ver = LAS_GetFullVersion();
fprintf(stderr,"%s", ver);
LASString_Free(ver);
exit(0);
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"--help") == 0)
{
usage();
exit(0);
}
else if (strcmp(argv[i],"--input") == 0
|| strcmp(argv[i],"-input") == 0
|| strcmp(argv[i],"-i") == 0
|| strcmp(argv[i],"-in") == 0)
{
i++;
file_name = argv[i];
}
else if (strcmp(argv[i], "--points") == 0
|| strcmp(argv[i], "--check") == 0
|| strcmp(argv[i], "--check_points") == 0
|| strcmp(argv[i], "-c") == 0
|| strcmp(argv[i], "-points") == 0
|| strcmp(argv[i], "-check") == 0
|| strcmp(argv[i], "-check_points") == 0)
{
check_points = TRUE;
}
else if (strcmp(argv[i], "--nocheck") == 0
|| strcmp(argv[i], "-nocheck") == 0)
{
check_points = FALSE;
}
else if (strcmp(argv[i], "--stdin") == 0
|| strcmp(argv[i], "-ilas") == 0)
{
use_stdin = TRUE;
}
else if (strcmp(argv[i], "--repair") == 0
|| strcmp(argv[i], "-r") == 0
|| strcmp(argv[i], "-repair_header") == 0
|| strcmp(argv[i], "-repair") == 0)
{
repair_header = TRUE;
check_points = TRUE;
}
else if (strcmp(argv[i], "--repair_bb") == 0
|| strcmp(argv[i], "--repair_bounding_box") == 0
|| strcmp(argv[i], "--repair_boundingbox") == 0
|| strcmp(argv[i], "-repair_bb") == 0
|| strcmp(argv[i], "-repair_bounding_box") == 0
|| strcmp(argv[i], "-repair_boundingbox") == 0
|| strcmp(argv[i], "-repair") == 0
|| strcmp(argv[i], "-rb") == 0)
{
repair_bounding_box = TRUE;
check_points = TRUE;
}
else if (strcmp(argv[i],"--system_identifier") == 0
|| strcmp(argv[i],"-system_identifier") == 0
|| strcmp(argv[i],"-s") == 0
|| strcmp(argv[i],"-sys_id") == 0)
{
i++;
system_identifier = (char*) malloc(31 * sizeof(char));
strcpy(system_identifier, argv[i]);
change_header = TRUE;
}
else if (strcmp(argv[i],"--generating_software") == 0
|| strcmp(argv[i],"-generating_software") == 0
|| strcmp(argv[i],"-g") == 0
|| strcmp(argv[i],"-gen_soft") == 0)
{
i++;
generating_software = (char*) malloc(31*sizeof(char));
strcpy(generating_software, argv[i]);
change_header = TRUE;
}
else if (strcmp(argv[i],"--file_creation") == 0
|| strcmp(argv[i],"-file_creation") == 0)
{
/* XXX - mloskot: Consider replacing atoi with strtol,
see http://www.iso-9899.info/wiki/Converting */
i++;
file_creation_day = (unsigned char)atoi(argv[i]);
i++;
file_creation_year = (unsigned char)atoi(argv[i]);
change_header = TRUE;
}
else if (strcmp(argv[i],"--skip_vlr") == 0 || strcmp(argv[i],"--no_vlr") == 0)
{
skip_vlr = TRUE;
}
else if (strcmp(argv[i],"--wkt") == 0)
{
wkt = TRUE;
}
else if (file_name == NULL)
{
file_name = argv[i];
}
else
{
usage();
fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
exit(1);
}
}
if (use_stdin) {
file_name = "stdin";
}
if (!file_name) {
LASError_Print("No filename was provided to be opened");
usage();
exit(1);
}
reader = LASReader_Create(file_name);
if (!reader) {
LASError_Print("Could not open file ");
exit(1);
}
header = LASReader_GetHeader(reader);
if (!header) {
LASError_Print("Could not get LASHeader ");
exit(1);
}
print_header(stdout, header, file_name, skip_vlr, wkt);
if (change_header) {
if (system_identifier) {
err = LASHeader_SetSystemId (header, system_identifier);
if (err) LASError_Print("Could not set SystemId");
}
if (generating_software) {
err = LASHeader_SetSoftwareId(header, generating_software);
if (err) LASError_Print("Could not set SoftwareId");
}
if ( file_creation_day || file_creation_year) {
err = LASHeader_SetCreationDOY(header, file_creation_day);
if (err) LASError_Print("Could not set file creation day");
err = LASHeader_SetCreationYear(header, file_creation_year);
if (err) LASError_Print("Could not set file creation year");
}
/* We need to wipe out the reader and make a writer. */
if (reader) {
LASReader_Destroy(reader);
reader = NULL;
}
writer = LASWriter_Create(file_name, header, LAS_MODE_APPEND);
if (!writer) {
LASError_Print("Problem creating LASWriterH object");
LASHeader_Destroy(header);
header = NULL;
exit(1);
}
if (writer) LASWriter_Destroy(writer);
writer = NULL;
if (header) LASHeader_Destroy(header);
header = NULL;
}
if (check_points)
{
if (!reader) {
reader = LASReader_Create(file_name);
if (!reader) {
LASError_Print("Could not open file ");
exit(1);
}
}
if (! header) {
header = LASReader_GetHeader(reader);
if (!header) {
LASError_Print("Could not get LASHeader ");
exit(1);
}
}
if (!summary)
summary = SummarizePoints(reader);
print_point_summary(stdout, summary, header);
if (repair_header) {
fprintf(stdout, "\n---------------------------------------------------------\n");
fprintf(stdout, " Repair Summary\n");
fprintf(stdout, "---------------------------------------------------------\n");
if (use_stdin) {
LASError_Print("Cannot update header information on piped input!");
exit(1);
}
if (! header) {
header = LASReader_GetHeader(reader);
if (!header) {
LASError_Print("Could not get LASHeader ");
exit(1);
}
}
if (! repair_bounding_box) {
if ( LASHeader_GetMinX(header) != LASPoint_GetX(summary->pmin) )
repair_bounding_box = TRUE;
if ( LASHeader_GetMinY(header) != LASPoint_GetY(summary->pmin) )
repair_bounding_box = TRUE;
if ( LASHeader_GetMinZ(header) != LASPoint_GetZ(summary->pmin) )
repair_bounding_box = TRUE;
if ( LASHeader_GetMaxX(header) != LASPoint_GetX(summary->pmax) )
repair_bounding_box = TRUE;
if ( LASHeader_GetMaxY(header) != LASPoint_GetY(summary->pmax) )
repair_bounding_box = TRUE;
if ( LASHeader_GetMaxZ(header) != LASPoint_GetZ(summary->pmax) )
repair_bounding_box = TRUE;
}
if (repair_bounding_box) {
fprintf(stdout, " Reparing Bounding Box...\n");
err = LASHeader_SetMin( header,
LASPoint_GetX(summary->pmin),
LASPoint_GetY(summary->pmin),
LASPoint_GetZ(summary->pmin)
);
if (err) {
LASError_Print("Could not set minimum for header ");
exit(1);
}
err = LASHeader_SetMax( header,
LASPoint_GetX(summary->pmax),
LASPoint_GetY(summary->pmax),
LASPoint_GetZ(summary->pmax)
);
if (err) {
LASError_Print("Could not set minimum for header ");
exit(1);
}
}
for (i = 0; i < 5; i++) {
if (LASHeader_GetPointRecordsByReturnCount(header, i) !=
summary->number_of_points_by_return[i])
{
update_return_counts = TRUE;
break;
}
}
if (update_return_counts) {
fprintf(stdout, " Reparing Point Count by Return...\n");
for (i = 0; i < 5; i++) {
LASHeader_SetPointRecordsByReturnCount( header,
i,
summary->number_of_points_by_return[i]);
}
}
if (reader) {
LASReader_Destroy(reader);
reader = NULL;
}
writer = LASWriter_Create(file_name, header, LAS_MODE_APPEND);
if (!writer) {
LASError_Print("Problem creating LASWriterH object for append");
LASHeader_Destroy(header);
header = NULL;
exit(1);
}
LASWriter_Destroy(writer);
writer = NULL;
LASHeader_Destroy(header);
header = NULL;
}
if (summary) {
LASPoint_Destroy(summary->pmin);
LASPoint_Destroy(summary->pmax);
free(summary);
}
}
if (reader) LASReader_Destroy(reader);
if (header) LASHeader_Destroy(header);
#ifdef HAVE_GDAL
/* Various GDAL related cleanups */
#ifdef OSRCleanup
OSRCleanup();
#endif
CPLFinderClean();
CPLFreeConfig();
CPLCleanupTLS();
#endif
return 0;
}
int main(int argc, char *argv[])
{
int i;
int use_stdin = FALSE;
int use_stdout = FALSE;
int skip_invalid = FALSE;
int verbose = FALSE;
char* file_name_in = 0;
char* file_name_out = 0;
char separator_sign = ' ';
char header_comment_sign = '\0';
char* parse_string = "xyz";
char printstring[256];
LASReaderH reader = NULL;
LASHeaderH header = NULL;
LASPointH p = NULL;
FILE* file_out = NULL;
int len;
uint32_t index = 0;
for (i = 1; i < argc; i++)
{
if ( strcmp(argv[i],"-h") == 0 ||
strcmp(argv[i],"--help") == 0
)
{
usage();
exit(0);
}
else if ( strcmp(argv[i],"-v") == 0 ||
strcmp(argv[i],"--verbose") == 0
)
{
verbose = TRUE;
}
else if ( strcmp(argv[i],"-s") == 0 ||
strcmp(argv[i],"--skip_invalid") == 0
)
{
skip_invalid = TRUE;
}
else if ( strcmp(argv[i], "--parse") == 0 ||
strcmp(argv[i], "-parse") == 0
)
{
i++;
parse_string = argv[i];
}
else if ( strcmp(argv[i], "--sep") == 0 ||
strcmp(argv[i], "-sep") == 0
)
{
i++;
if (strcmp(argv[i],"komma") == 0)
{
separator_sign = ',';
}
else if (strcmp(argv[i],"tab") == 0)
{
separator_sign = '\t';
}
else if ( strcmp(argv[i],"dot") == 0 ||
strcmp(argv[i],"period") == 0
)
{
separator_sign = '.';
}
else if (strcmp(argv[i],"colon") == 0)
{
separator_sign = ':';
}
else if ( strcmp(argv[i],"scolon") == 0 ||
strcmp(argv[i],"semicolon") == 0
)
{
separator_sign = ';';
}
else if ( strcmp(argv[i],"hyphen") == 0 ||
strcmp(argv[i],"minus") == 0
)
{
separator_sign = '-';
}
else if (strcmp(argv[i],"space") == 0)
{
separator_sign = ' ';
}
else
{
fprintf(stderr, "ERROR: unknown seperator '%s'\n",argv[i]);
usage();
exit(1);
}
}
else if ( strcmp(argv[i], "--header") == 0 ||
strcmp(argv[i], "--comment") == 0 ||
strcmp(argv[i], "-header") == 0 ||
strcmp(argv[i], "-comment") == 0 ||
strcmp(argv[i], "-head") == 0
)
{
i++;
if (strcmp(argv[i],"komma") == 0)
{
header_comment_sign = ',';
}
else if (strcmp(argv[i],"colon") == 0)
{
header_comment_sign = ':';
}
else if ( strcmp(argv[i],"scolon") == 0 ||
strcmp(argv[i],"semicolon") == 0
)
{
header_comment_sign = ';';
}
else if ( strcmp(argv[i],"pound") == 0 ||
strcmp(argv[i],"hash") == 0
)
{
header_comment_sign = '#';
}
else if (strcmp(argv[i],"percent") == 0)
{
header_comment_sign = '%';
}
else if (strcmp(argv[i],"dollar") == 0)
{
header_comment_sign = '$';
}
else if (strcmp(argv[i],"star") == 0)
{
header_comment_sign = '*';
}
else
{
fprintf(stderr, "ERROR: unknown comment symbol '%s'\n",argv[i]);
usage();
exit(1);
}
}
else if ( strcmp(argv[i], "--stdin") == 0 ||
strcmp(argv[i], "-ilas") == 0
)
{
use_stdin = TRUE;
}
else if ( strcmp(argv[i], "--stdout") == 0
)
{
use_stdout = TRUE;
}
else if ( strcmp(argv[i],"--input") == 0 ||
strcmp(argv[i],"-input") == 0 ||
strcmp(argv[i],"-i") == 0 ||
strcmp(argv[i],"-in") == 0
)
{
i++;
file_name_in = argv[i];
}
else if ( strcmp(argv[i],"--output") == 0 ||
strcmp(argv[i],"--out") == 0 ||
strcmp(argv[i],"-out") == 0 ||
strcmp(argv[i],"-o") == 0
)
{
i++;
file_name_out = argv[i];
}
else if (i == argc - 2 && file_name_in == 0 && file_name_out == 0)
{
file_name_in = argv[i];
}
else if (i == argc - 1 && file_name_in == 0 && file_name_out == 0)
{
file_name_in = argv[i];
}
else if (i == argc - 1 && file_name_in && file_name_out == 0)
{
file_name_out = argv[i];
}
else
{
fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
usage();
exit(1);
}
} /* end looping through argc/argv */
if (use_stdin) file_name_in = "stdin";
reader = LASReader_Create(file_name_in);
if (!reader) {
LASError_Print("Unable to read file");
exit(1);
}
header = LASReader_GetHeader(reader);
if (!header) {
LASError_Print("Unable to fetch header for file");
exit(1);
}
if (use_stdout)
{
file_out = stdout;
}
else
{
if (file_name_out == NULL)
{
if (file_name_in == NULL)
{
LASError_Print("No input filename was specified");
usage();
exit(1);
}
len = (int)strlen(file_name_in);
file_name_out = strdup(file_name_in);
if (file_name_out[len-3] == '.' && file_name_out[len-2] == 'g' && file_name_out[len-1] == 'z')
{
len = len - 4;
}
while (len > 0 && file_name_out[len] != '.')
{
len--;
}
file_name_out[len] = '.';
file_name_out[len+1] = 't';
file_name_out[len+2] = 'x';
file_name_out[len+3] = 't';
file_name_out[len+4] = '\0';
}
file_out = fopen(file_name_out, "w");
if (file_out == 0)
{
LASError_Print("Could not open file for write");
usage();
exit(1);
}
}
if (verbose)
{
print_header(stderr, header, file_name_in);
}
if (header_comment_sign)
{
fprintf(file_out,
"%c file signature: '%s'\012",
header_comment_sign,
LASHeader_GetFileSignature(header)
);
fprintf(file_out,
"%c file source ID: %d\012",
header_comment_sign,
LASHeader_GetFileSourceId(header)
);
fprintf(file_out,
"%c reserved: %d\012",
header_comment_sign,
LASHeader_GetReserved(header)
);
fprintf(file_out,
"%c project ID GUID: %s\012",
header_comment_sign,
LASHeader_GetProjectId(header)
);
fprintf(file_out,
"%c version major.minor: %d.%d\012",
header_comment_sign,
LASHeader_GetVersionMajor(header),
LASHeader_GetVersionMinor(header)
);
fprintf(file_out,
"%c system_identifier: '%s'\012",
header_comment_sign,
LASHeader_GetSystemId(header)
);
fprintf(file_out,
"%c generating_software: '%s'\012",
header_comment_sign,
LASHeader_GetSoftwareId(header)
);
fprintf(file_out,
"%c file creation day/year: %d/%d\012",
header_comment_sign,
LASHeader_GetCreationDOY(header),
LASHeader_GetCreationYear(header)
);
fprintf(file_out,
"%c header size %d\012",
header_comment_sign,
LASHeader_GetHeaderSize(header)
);
fprintf(file_out,
"%c offset to point data %d\012",
header_comment_sign,
LASHeader_GetDataOffset(header)
);
fprintf(file_out,
"%c number var. length records %d\012",
header_comment_sign,
LASHeader_GetRecordsCount(header)
);
fprintf(file_out,
"%c point data format %d\012",
header_comment_sign,
LASHeader_GetDataFormatId(header)
);
fprintf(file_out,
"%c point data record length %d\012",
header_comment_sign,
LASHeader_GetDataRecordLength(header)
);
fprintf(file_out,
"%c number of point records %d\012",
header_comment_sign,
LASHeader_GetPointRecordsCount(header)
);
fprintf(file_out,
"%c number of points by return %d %d %d %d %d\012",
header_comment_sign,
LASHeader_GetPointRecordsByReturnCount(header, 0),
LASHeader_GetPointRecordsByReturnCount(header, 1),
LASHeader_GetPointRecordsByReturnCount(header, 2),
LASHeader_GetPointRecordsByReturnCount(header, 3),
LASHeader_GetPointRecordsByReturnCount(header, 4)
);
fprintf(file_out,
"%c scale factor x y z %.6f %.6f %.6f\n",
header_comment_sign,
LASHeader_GetScaleX(header),
LASHeader_GetScaleY(header),
LASHeader_GetScaleZ(header)
);
fprintf(file_out,
"%c offset x y z %.6f %.6f %.6f\n",
header_comment_sign,
LASHeader_GetOffsetX(header),
LASHeader_GetOffsetY(header),
LASHeader_GetOffsetZ(header)
);
fprintf(file_out,
"%c min x y z %.6f %.6f %.6f\n",
header_comment_sign,
LASHeader_GetMinX(header),
LASHeader_GetMinY(header),
LASHeader_GetMinZ(header)
);
fprintf(file_out,
"%c max x y z %.6f %.6f %.6f\n",
header_comment_sign,
LASHeader_GetMaxX(header),
LASHeader_GetMaxY(header),
LASHeader_GetMaxZ(header)
);
}
p = LASReader_GetNextPoint(reader);
while (p)
{
if (skip_invalid && !LASPoint_IsValid(p)) {
if (verbose) {
LASError_Print("Skipping writing invalid point...");
}
p = LASReader_GetNextPoint(reader);
index -=1;
continue;
}
i = 0;
for (;;)
{
LASColorH color = LASPoint_GetColor(p);
switch (parse_string[i])
{
/* // the x coordinate */
case 'x':
lidardouble2string(printstring, LASPoint_GetX(p)); fprintf(file_out, printstring);
break;
/* // the y coordinate */
case 'y':
lidardouble2string(printstring, LASPoint_GetY(p)); fprintf(file_out, printstring);
break;
/* // the z coordinate */
case 'z':
lidardouble2string(printstring, LASPoint_GetZ(p)); fprintf(file_out, printstring);
break;
/* // the gps-time */
case 't':
lidardouble2string(printstring,LASPoint_GetTime(p)); fprintf(file_out, printstring);
break;
/* // the intensity */
case 'i':
fprintf(file_out, "%d", LASPoint_GetIntensity(p));
break;
/* the scan angle */
case 'a':
fprintf(file_out, "%d", LASPoint_GetScanAngleRank(p));
break;
/* the number of the return */
case 'r':
fprintf(file_out, "%d", LASPoint_GetReturnNumber(p));
break;
/* the classification */
case 'c':
fprintf(file_out, "%d", LASPoint_GetClassification(p));
break;
/* the user data */
case 'u':
fprintf(file_out, "%d", LASPoint_GetUserData(p));
break;
/* the number of returns of given pulse */
case 'n':
fprintf(file_out, "%d", LASPoint_GetNumberOfReturns(p));
break;
/* the red channel color */
case 'R':
fprintf(file_out, "%d", LASColor_GetRed(color));
break;
/* the green channel color */
case 'G':
fprintf(file_out, "%d", LASColor_GetGreen(color));
break;
/* the blue channel color */
case 'B':
fprintf(file_out, "%d", LASColor_GetBlue(color));
break;
case 'M':
fprintf(file_out, "%d", index);
break;
/*
case 'p': // the point source ID
fprintf(file_out, "%d", lasreader->point.point_source_ID);
break;
*/
/* the edge of flight line flag */
case 'e':
fprintf(file_out, "%d", LASPoint_GetFlightLineEdge(p));
break;
/* the direction of scan flag */
case 'd':
fprintf(file_out, "%d", LASPoint_GetScanDirection(p));
break;
}
i++;
if (parse_string[i])
{
fprintf(file_out, "%c", separator_sign);
}
else
{
fprintf(file_out, "\012");
break;
}
LASColor_Destroy(color);
}
p = LASReader_GetNextPoint(reader);
index +=1;
}
LASReader_Destroy(reader);
LASHeader_Destroy(header);
fclose(file_out);
return 0;
}
