void test_point_geometry_bytes(const PCSCHEMA *s, size_t expectedgeomwkbsize,
const char *pthexbytes, const char *expectedgeomhexbytes)
{
/* point
byte: endianness (1 = NDR, 0 = XDR)
uint32: pcid (key to POINTCLOUD_SCHEMAS)
uchar[]: data (interpret relative to pcid)
*/
/* geometry
byte: endianness (1 = NDR, 0 = XDR)
uint32: point type (XYZ=01000080, XYM=01000040, XY=01000000, XYZM=010000C0)
double[]: XY(Z?)(M?) coordinates
*/
PCPOINT *pt;
uint8_t *ptwkb, *geomwkb;
char *geomhexbytes;
size_t pthexsize, geomwkbsize;
pthexsize = strlen(pthexbytes);
ptwkb = pc_bytes_from_hexbytes(pthexbytes, pthexsize);
pt = pc_point_from_wkb(s, ptwkb, pthexsize/2);
CU_ASSERT_PTR_NOT_NULL(pt);
geomwkb = pc_point_to_geometry_wkb(pt, &geomwkbsize);
CU_ASSERT_EQUAL(geomwkbsize,expectedgeomwkbsize);
geomhexbytes = pc_hexbytes_from_bytes(geomwkb,geomwkbsize);
CU_ASSERT_STRING_EQUAL(geomhexbytes, expectedgeomhexbytes);
pcfree(geomhexbytes);
pcfree(geomwkb);
pc_point_free(pt);
pcfree(ptwkb);
}
/* Setup/teardown for this suite */
static int
init_suite(void)
{
char *xmlstr = file_to_str(xmlfile);
schema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !schema ) return 1;
xmlstr = file_to_str(simplexmlfile);
simpleschema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !simpleschema ) return 1;
xmlstr = file_to_str(simplexmlfile_nointensity);
simpleschema_nointensity = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !simpleschema_nointensity ) return 1;
xmlstr = file_to_str(lasxmlfile);
lasschema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !lasschema ) return 1;
xmlstr = file_to_str(simplelazxmlfile);
simplelazschema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !simplelazschema ) return 1;
return 0;
}
/* Setup/teardown for this suite */
static int
init_suite(void)
{
char *xmlstr;
xmlstr = file_to_str(xmlfile);
schema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !schema ) return 1;
xmlstr = file_to_str(xmlfile_xy);
schema_xy = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !schema_xy ) return 1;
xmlstr = file_to_str(xmlfile_xyz);
schema_xyz = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !schema_xyz ) return 1;
xmlstr = file_to_str(xmlfile_xym);
schema_xym = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !schema_xym ) return 1;
xmlstr = file_to_str(xmlfile_xyzm);
schema_xyzm = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !schema_xyzm ) return 1;
return 0;
}
static void
test_patch_pointn_laz_compression()
{
// 00 endian (big)
// 00000000 pcid
// 00000000 compression
// 00000003 npoints
// 0000000800000003000000050006 pt1 (XYZi)
// 0000000200000003000000040008 pt2 (XYZi)
// 0000000200000003000000040009 pt3 (XYZi)
char *hexbuf = "00000000000000000000000003000000080000000300000005000600000002000000030000000400080000000200000003000000040009";
size_t hexsize = strlen(hexbuf);
uint8_t *wkb = bytes_from_hexbytes(hexbuf, hexsize);
char *str;
PCPATCH *pa = pc_patch_from_wkb(simpleschema, wkb, hexsize/2);
PCPOINTLIST *li = pc_pointlist_from_patch(pa);
PCPATCH_LAZPERF* paz = pc_patch_lazperf_from_pointlist(li);
PCPOINT *pt = pc_patch_pointn((PCPATCH*) paz, 2);
CU_ASSERT(pt != NULL);
str = pc_point_to_string(pt);
CU_ASSERT_STRING_EQUAL(str, "{\"pcid\":0,\"pt\":[0.02,0.03,0.04,8]}");
pc_patch_free((PCPATCH *)paz);
pc_point_free(pt);
pcfree(str);
pcfree(wkb);
pc_patch_free(pa);
pc_pointlist_free(li);
}
static void
test_patch_filter()
{
int i;
int npts = 20;
PCPOINTLIST *pl1, *pl2;
PCPATCH *pa1, *pa2, *pa3, *pa4;
char *str1, *str2;
pl1 = pc_pointlist_make(npts);
pl2 = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
PCPOINT *pt1 = pc_point_make(simpleschema);
PCPOINT *pt2 = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt1, "x", i);
pc_point_set_double_by_name(pt1, "y", i);
pc_point_set_double_by_name(pt1, "Z", i*0.1);
pc_point_set_double_by_name(pt1, "intensity", 100-i);
pc_pointlist_add_point(pl1, pt1);
pc_point_set_double_by_name(pt2, "x", i);
pc_point_set_double_by_name(pt2, "y", i);
pc_point_set_double_by_name(pt2, "Z", i*0.1);
pc_point_set_double_by_name(pt2, "intensity", 100-i);
pc_pointlist_add_point(pl2, pt2);
}
// PCPATCH* pc_patch_filter(const PCPATCH *pa, uint32_t dimnum, PC_FILTERTYPE filter, double val1, double val2);
pa1 = (PCPATCH*)pc_patch_dimensional_from_pointlist(pl1);
// printf("pa1\n%s\n", pc_patch_to_string(pa1));
pa2 = pc_patch_filter(pa1, 0, PC_GT, 17, 20);
str1 = pc_patch_to_string(pa2);
// printf("pa2\n%s\n", str1);
CU_ASSERT_STRING_EQUAL(str1, "{\"pcid\":0,\"pts\":[[18,18,1.8,82],[19,19,1.9,81]]}");
pa3 = (PCPATCH*)pc_patch_uncompressed_from_pointlist(pl2);
// printf("\npa3\n%s\n", pc_patch_to_string(pa3));
pa4 = pc_patch_filter(pa3, 0, PC_GT, 17, 20);
str2 = pc_patch_to_string(pa4);
// printf("\npa4\n%s\n", str2);
CU_ASSERT_STRING_EQUAL(str2, "{\"pcid\":0,\"pts\":[[18,18,1.8,82],[19,19,1.9,81]]}");
pcfree(str1);
pcfree(str2);
pc_pointlist_free(pl1);
pc_pointlist_free(pl2);
pc_patch_free(pa1);
pc_patch_free(pa3);
pc_patch_free(pa4);
pc_patch_free(pa2);
return;
}
/*
* Write an uncompressed patch out to hex
*/
static void
test_patch_hex_out()
{
// 00 endian
// 00000000 pcid
// 00000000 compression
// 00000002 npoints
// 0000000200000003000000050006 pt1 (XYZi)
// 0000000200000003000000050008 pt2 (XYZi)
static char *wkt_result = "{\"pcid\":0,\"pts\":[[0.02,0.03,0.05,6],[0.02,0.03,0.05,8]]}";
static char *hexresult_xdr =
"0000000000000000000000000200000002000000030000000500060000000200000003000000050008";
static char *hexresult_ndr =
"0100000000000000000200000002000000030000000500000006000200000003000000050000000800";
double d0[4] = { 0.02, 0.03, 0.05, 6 };
double d1[4] = { 0.02, 0.03, 0.05, 8 };
PCPOINT *pt0 = pc_point_from_double_array(simpleschema, d0, 4);
PCPOINT *pt1 = pc_point_from_double_array(simpleschema, d1, 4);
PCPATCH_UNCOMPRESSED *pa;
uint8_t *wkb;
size_t wkbsize;
char *hexwkb;
char *wkt;
PCPOINTLIST *pl = pc_pointlist_make(2);
pc_pointlist_add_point(pl, pt0);
pc_pointlist_add_point(pl, pt1);
pa = pc_patch_uncompressed_from_pointlist(pl);
wkb = pc_patch_uncompressed_to_wkb(pa, &wkbsize);
// printf("wkbsize %zu\n", wkbsize);
hexwkb = hexbytes_from_bytes(wkb, wkbsize);
// printf("hexwkb %s\n", hexwkb);
// printf("hexresult_ndr %s\n", hexresult_ndr);
// printf("machine_endian %d\n", machine_endian());
if ( machine_endian() == PC_NDR )
{
CU_ASSERT_STRING_EQUAL(hexwkb, hexresult_ndr);
}
else
{
CU_ASSERT_STRING_EQUAL(hexwkb, hexresult_xdr);
}
wkt = pc_patch_uncompressed_to_string(pa);
// printf("wkt %s\n", wkt);
CU_ASSERT_STRING_EQUAL(wkt, wkt_result);
pc_patch_free((PCPATCH*)pa);
pc_pointlist_free(pl);
pcfree(hexwkb);
pcfree(wkb);
pcfree(wkt);
}
static void
pc_dstats_free(PCDOUBLESTATS *stats)
{
if ( ! stats) return;
if ( stats->dims ) pcfree(stats->dims);
pcfree(stats);
return;
}
void
pc_point_free(PCPOINT *pt)
{
if ( ! pt->readonly )
{
pcfree(pt->data);
}
pcfree(pt);
}
void
pc_patch_uncompressed_free(PCPATCH_UNCOMPRESSED *patch)
{
if ( patch->data && ! patch->readonly )
{
pcfree(patch->data);
}
pcfree(patch);
}
/** Release the memory behind the PCDIMENSION struct */
static void
pc_dimension_free(PCDIMENSION *pcd)
{
/* Assumption: No memory in the dimension is owned somewhere else */
if ( pcd->description )
pcfree(pcd->description);
if ( pcd->name )
pcfree(pcd->name);
pcfree(pcd);
}
static void
test_endian_flip()
{
PCPOINT *pt;
double a1, a2, a3, a4, b1, b2, b3, b4;
int rv;
uint8_t *ptr;
/* All at once */
pt = pc_point_make(schema);
a1 = 1.5;
a2 = 1501500.12;
a3 = 19112;
a4 = 200;
rv = pc_point_set_double_by_name(pt, "X", a1);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_set_double_by_name(pt, "Z", a2);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_set_double_by_name(pt, "Intensity", a3);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_set_double_by_name(pt, "UserData", a4);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "X", &b1);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "Z", &b2);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "Intensity", &b3);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "UserData", &b4);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
CU_ASSERT_DOUBLE_EQUAL(a1, b1, 0.0000001);
CU_ASSERT_DOUBLE_EQUAL(a2, b2, 0.0000001);
CU_ASSERT_DOUBLE_EQUAL(a3, b3, 0.0000001);
CU_ASSERT_DOUBLE_EQUAL(a4, b4, 0.0000001);
ptr = uncompressed_bytes_flip_endian(pt->data, schema, 1);
pcfree(pt->data);
pt->data = uncompressed_bytes_flip_endian(ptr, schema, 1);
pcfree(ptr);
rv = pc_point_get_double_by_name(pt, "X", &b1);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "Z", &b2);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "Intensity", &b3);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
rv = pc_point_get_double_by_name(pt, "UserData", &b4);
CU_ASSERT_EQUAL(rv, PC_SUCCESS);
CU_ASSERT_DOUBLE_EQUAL(a1, b1, 0.0000001);
CU_ASSERT_DOUBLE_EQUAL(a2, b2, 0.0000001);
CU_ASSERT_DOUBLE_EQUAL(a3, b3, 0.0000001);
CU_ASSERT_DOUBLE_EQUAL(a4, b4, 0.0000001);
pc_point_free(pt);
}
void
pc_pointlist_free(PCPOINTLIST *pl)
{
int i;
for ( i = 0; i < pl->npoints; i++ )
{
pc_point_free(pl->points[i]);
}
pcfree(pl->points);
pcfree(pl);
return;
}
void
pc_patch_uncompressed_free(PCPATCH_UNCOMPRESSED *patch)
{
assert(patch);
assert(patch->schema);
pc_patch_free_stats((PCPATCH*) patch);
if ( patch->data && ! patch->readonly )
{
pcfree(patch->data);
}
pcfree(patch);
}
static void
test_wkb_lazperf()
{
PCPOINT *pt;
int i;
int npts = 400;
PCPOINTLIST *pl;
PCPATCH_LAZPERF *pal1, *pal2;
PCPATCH_UNCOMPRESSED *pau;
uint8_t *wkb1, *wkb2;
size_t wkbsize;
// build a list of points
pl = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "x", i*2.0);
pc_point_set_double_by_name(pt, "y", i*1.9);
pc_point_set_double_by_name(pt, "Z", i*0.34);
pc_point_set_double_by_name(pt, "intensity", 10);
pc_pointlist_add_point(pl, pt);
}
// build patch lazperf
pal1 = pc_patch_lazperf_from_pointlist(pl);
// get the corresponding wkb
wkb1 = pc_patch_lazperf_to_wkb(pal1, &wkbsize);
// rebuild a lazperf patch thanks to the wkb
pal2 = (PCPATCH_LAZPERF*) pc_patch_lazperf_from_wkb( pal1->schema, wkb1, wkbsize);
// get the wkb reference
pau = pc_patch_uncompressed_from_pointlist(pl);
wkb2 = pc_patch_uncompressed_to_wkb( pau, &wkbsize );
// compare wkb
CU_ASSERT_STRING_EQUAL(wkb1, wkb2);
// free
pc_patch_free((PCPATCH*) pal1);
pc_patch_free((PCPATCH*) pal2);
pc_patch_free((PCPATCH*) pau);
pc_pointlist_free(pl);
pcfree(wkb1);
pcfree(wkb2);
}
/**
* Free the standard stats object for in memory patches
*/
void
pc_stats_free(PCSTATS *stats)
{
if ( stats->min.readonly != PC_TRUE )
pcfree(stats->min.data);
if ( stats->max.readonly != PC_TRUE )
pcfree(stats->max.data);
if ( stats->avg.readonly != PC_TRUE )
pcfree(stats->avg.data);
pcfree(stats);
return;
}
/* Setup/teardown for this suite */
static int
init_suite(void)
{
char *xmlstr = file_to_str(simplexmlfile);
simpleschema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !simpleschema ) return 1;
xmlstr = file_to_str(multipledimxmlfile);
multipledimschema = pc_schema_from_xml(xmlstr);
pcfree(xmlstr);
if ( !multipledimschema ) return 1;
return 0;
}
static void
test_patch_pointn_last_first()
{
// 00 endian (big)
// 00000000 pcid
// 00000000 compression
// 00000003 npoints
// 0000000800000003000000050006 pt1 (XYZi)
// 0000000200000003000000040008 pt2 (XYZi)
// 0000000200000003000000040009 pt3 (XYZi)
char *hexbuf = "00000000000000000000000003000000080000000300000005000600000002000000030000000400080000000200000003000000040009";
size_t hexsize = strlen(hexbuf);
uint8_t *wkb = bytes_from_hexbytes(hexbuf, hexsize);
char *str;
PCPATCH *pa = pc_patch_from_wkb(simpleschema, wkb, hexsize/2);
PCPOINT *pt = pc_patch_pointn(pa, -1);
str = pc_point_to_string(pt);
CU_ASSERT_STRING_EQUAL(str, "{\"pcid\":0,\"pt\":[0.02,0.03,0.04,9]}");
pc_point_free(pt);
free(str);
pt = pc_patch_pointn(pa, -3);
str = pc_point_to_string(pt);
CU_ASSERT_STRING_EQUAL(str, "{\"pcid\":0,\"pt\":[0.08,0.03,0.05,6]}");
pc_point_free(pt);
free(str);
pc_patch_free(pa);
pcfree(wkb);
}
static void
test_patch_union()
{
int i;
int npts = 20;
PCPOINTLIST *pl1;
PCPATCH *pu;
PCPATCH **palist;
pl1 = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
PCPOINT *pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "x", i*2.0);
pc_point_set_double_by_name(pt, "y", i*1.9);
pc_point_set_double_by_name(pt, "Z", i*0.34);
pc_point_set_double_by_name(pt, "intensity", 10);
pc_pointlist_add_point(pl1, pt);
}
palist = pcalloc(2*sizeof(PCPATCH*));
palist[0] = (PCPATCH*)pc_patch_dimensional_from_pointlist(pl1);
palist[1] = (PCPATCH*)pc_patch_uncompressed_from_pointlist(pl1);
pu = pc_patch_from_patchlist(palist, 2);
CU_ASSERT_EQUAL(pu->npoints, 2*npts);
pc_pointlist_free(pl1);
pc_patch_free(pu);
pc_patch_free(palist[0]);
pc_patch_free(palist[1]);
pcfree(palist);
}
static void
test_sort_patch_is_sorted_no_compression()
{
// 00 endian (big)
// 00000000 pcid
// 00000000 compression
// 00000002 npoints
// 0000000800000003000000050006 pt1 (XYZi)
// 0000000200000003000000040008 pt2 (XYZi)
// 0000000200000003000000040009 pt3 (XYZi)
// init data
PCPATCH *pasort;
char *hexbuf = "00000000000000000000000003000000080000000300000005000600000002000000030000000400080000000200000003000000040009";
size_t hexsize = strlen(hexbuf);
uint8_t *wkb = bytes_from_hexbytes(hexbuf, hexsize);
PCPATCH *pa = pc_patch_from_wkb(schema, wkb, hexsize/2);
PCPOINTLIST *li = pc_pointlist_from_patch(pa);
const char *X[] = {"X"};
CU_ASSERT_EQUAL(pc_patch_is_sorted(pa, X, 1, PC_FALSE), PC_FALSE);
CU_ASSERT_EQUAL(pc_patch_is_sorted(pa, X, 1, PC_TRUE), PC_FALSE);
pasort = pc_patch_sort(pa, X, 1);
CU_ASSERT_EQUAL(pc_patch_is_sorted(pasort, X, 1, PC_FALSE), PC_FALSE);
CU_ASSERT_EQUAL(pc_patch_is_sorted(pasort, X, 1, PC_TRUE), PC_TRUE);
// free
pcfree(wkb);
pc_patch_free(pa);
pc_patch_free(pasort);
pc_pointlist_free(li);
}
static void
test_patch_pointn_ght_compression()
{
// 00 endian (big)
// 00000000 pcid
// 00000000 compression
// 00000003 npoints
// 0000000800000003000000050006 pt1 (XYZi)
// 0000000200000003000000040008 pt2 (XYZi)
// 0000000200000003000000040009 pt3 (XYZi)
char *hexbuf = "00000000000000000000000003000000080000000300000005000600000002000000030000000400080000000200000003000000040009";
size_t hexsize = strlen(hexbuf);
uint8_t *wkb = bytes_from_hexbytes(hexbuf, hexsize);
PCPATCH *pa = pc_patch_from_wkb(simpleschema, wkb, hexsize/2);
PCPOINTLIST *li = pc_pointlist_from_patch(pa);
#ifdef HAVE_LIBGHT
PCPATCH_GHT* pag = pc_patch_ght_from_pointlist(li);
PCPOINT *pt = pc_patch_pointn((PCPATCH*) pag, 2);
CU_ASSERT(pt != NULL);
CU_ASSERT_STRING_EQUAL(pc_point_to_string(pt), "{\"pcid\":0,\"pt\":[0.02,0.03,0.04,8]}");
pc_patch_free( (PCPATCH*) pag );
pc_point_free(pt);
#endif
// free
pcfree(wkb);
pc_patch_free(pa);
pc_pointlist_free(li);
}
/*
* Can we read this example point value?
*/
static void
test_schema_xy()
{
/*
"Intensity", "ReturnNumber", "NumberOfReturns", "ScanDirectionFlag", "EdgeOfFlightLine", "Classification", "ScanAngleRank", "UserData", "PointSourceId", "Time", "Red", "Green", "Blue", "PointID", "BlockID", "X", "Y", "Z"
25, 1, 1, 1, 0, 1, 6, 124, 7327, 246093, 39, 57, 56, 20, 0, -125.0417204, 49.2540081, 128.85
*/
static char *hexpt = "01010000000AE9C90307A1100522A5000019000101010001067C9F1C4953C474650A0E412700390038001400000000000000876B6601962F750155320000";
uint8_t *bytes = bytes_from_hexbytes(hexpt, strlen(hexpt));
PCPOINT *pt;
double val;
pt = pc_point_from_wkb(lasschema, bytes, strlen(hexpt)/2);
pc_point_get_double_by_name(pt, "x", &val);
CU_ASSERT_DOUBLE_EQUAL(val, -125.0417204, 0.00001);
pc_point_free(pt);
pt = pc_point_from_wkb(lasschema, bytes, strlen(hexpt)/2);
pc_point_get_double_by_name(pt, "y", &val);
CU_ASSERT_DOUBLE_EQUAL(val, 49.2540081, 0.00001);
pc_point_free(pt);
pcfree(bytes);
}
int
pc_patch_uncompressed_compute_extent(PCPATCH_UNCOMPRESSED *patch)
{
int i;
PCPOINT *pt = pc_point_from_data(patch->schema, patch->data);
PCBOUNDS b;
double x, y;
/* Calculate bounds */
pc_bounds_init(&b);
for ( i = 0; i < patch->npoints; i++ )
{
/* Just push the data buffer forward by one point at a time */
pt->data = patch->data + i * patch->schema->size;
x = pc_point_get_x(pt);
y = pc_point_get_y(pt);
if ( b.xmin > x ) b.xmin = x;
if ( b.ymin > y ) b.ymin = y;
if ( b.xmax < x ) b.xmax = x;
if ( b.ymax < y ) b.ymax = y;
}
patch->bounds = b;
pcfree(pt);
return PC_SUCCESS;
}
static void
test_patch_range_compression_lazperf()
{
int i;
int npts = 20;
PCPOINTLIST *pl;
PCPATCH *pa;
PCPATCH *par;
char *str;
pl = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
PCPOINT *pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "X", i);
pc_point_set_double_by_name(pt, "Y", i);
pc_point_set_double_by_name(pt, "Z", i * 0.1);
pc_point_set_double_by_name(pt, "Intensity", 100 - i);
pc_pointlist_add_point(pl, pt);
}
pa = (PCPATCH*)pc_patch_lazperf_from_pointlist(pl);
par = pc_patch_range(pa, 16, 4);
str = pc_patch_to_string(par);
CU_ASSERT_STRING_EQUAL(str,
"{\"pcid\":0,\"pts\":[[15,15,1.5,85],[16,16,1.6,84],[17,17,1.7,83],[18,18,1.8,82]]}");
pcfree(str);
pc_patch_free(par);
pc_patch_free(pa);
pc_pointlist_free(pl);
}
static void
test_patch_range_compression_none_with_full_range()
{
int i;
int npts = 4;
PCPOINTLIST *pl;
PCPATCH *pa;
PCPATCH *par;
char *str;
pl = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
PCPOINT *pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "X", i);
pc_point_set_double_by_name(pt, "Y", i);
pc_point_set_double_by_name(pt, "Z", i * 0.1);
pc_point_set_double_by_name(pt, "Intensity", 100 - i);
pc_pointlist_add_point(pl, pt);
}
pa = (PCPATCH*)pc_patch_uncompressed_from_pointlist(pl);
par = pc_patch_range(pa, 1, npts);
CU_ASSERT(pa == par);
str = pc_patch_to_string(par);
CU_ASSERT_STRING_EQUAL(str,
"{\"pcid\":0,\"pts\":[[0,0,0,100],[1,1,0.1,99],[2,2,0.2,98],[3,3,0.3,97]]}");
pcfree(str);
pc_patch_free(pa);
pc_pointlist_free(pl);
}
static void
test_pointlist_lazperf()
{
PCPOINT *pt;
int i;
int npts = 400;
PCPOINTLIST *pl1, *pl2;
PCPATCH_LAZPERF *pch1;
PCPATCH_UNCOMPRESSED *pa1, *pa2;
char *wkt1, *wkt2;
// build a list of points
pl1 = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "x", i*2.0);
pc_point_set_double_by_name(pt, "y", i*1.9);
pc_point_set_double_by_name(pt, "Z", i*0.34);
pc_point_set_double_by_name(pt, "intensity", 10);
pc_pointlist_add_point(pl1, pt);
}
// compress the list in a lazperf patch
pch1 = pc_patch_lazperf_from_pointlist( pl1 );
// decompress the lazperf patch in a pointlist
pl2 = pc_pointlist_from_lazperf(pch1);
// test that the string representation of pointlist is equal
pa1 = pc_patch_uncompressed_from_pointlist( pl1 );
pa2 = pc_patch_uncompressed_from_lazperf( pch1 );
wkt1 = pc_patch_uncompressed_to_string(pa1);
wkt2 = pc_patch_uncompressed_to_string(pa2);
CU_ASSERT_STRING_EQUAL(wkt1, wkt2);
pc_patch_free((PCPATCH*) pch1 );
pc_patch_free((PCPATCH*) pa1);
pc_patch_free((PCPATCH*) pa2);
pc_pointlist_free(pl1);
pc_pointlist_free(pl2);
pcfree(wkt1);
pcfree(wkt2);
}
static void
test_patch_set_schema_compression_ght()
{
// init data
PCPATCH_GHT *pag;
PCPATCH *pat0, *pat1;
PCPOINTLIST *pl;
PCPOINT *pt;
char *str;
int i;
int npts = 4;
// build a patch
pl = pc_pointlist_make(npts);
for ( i = npts; i >= 0; i-- )
{
pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "X", i * 0.1);
pc_point_set_double_by_name(pt, "Y", i * 0.2);
pc_point_set_double_by_name(pt, "Z", i * 0.3);
pc_point_set_double_by_name(pt, "Intensity", 10);
pc_pointlist_add_point(pl, pt);
}
pag = pc_patch_ght_from_pointlist(pl);
// assign a valid schema to the patch
pat0 = pc_patch_set_schema((PCPATCH*) pag, simpleschema_nointensity, 0.0);
CU_ASSERT(pat0 != NULL);
str = pc_patch_to_string(pat0);
CU_ASSERT_STRING_EQUAL(str, "{\"pcid\":0,\"pts\":[[0.4,0.8,1.2],[0.3,0.6,0.9],[0.2,0.4,0.6],[0.1,0.2,0.3],[0,0,0]]}");
pcfree(str);
// assign a schema with unknown dimension to the patch
pat1 = pc_patch_set_schema(pat0, simpleschema, 0.0);
CU_ASSERT(pat1 != NULL);
str = pc_patch_to_string(pat1);
CU_ASSERT_STRING_EQUAL(str, "{\"pcid\":0,\"pts\":[[0.4,0.8,1.2,0],[0.3,0.6,0.9,0],[0.2,0.4,0.6,0],[0.1,0.2,0.3,0],[0,0,0,0]]}");
pcfree(str);
pc_patch_free(pat0);
pc_patch_free(pat1);
pc_patch_free((PCPATCH*) pag);
pc_pointlist_free(pl);
}
void
pc_patch_dimensional_free(PCPATCH_DIMENSIONAL *pdl)
{
int i;
assert(pdl);
assert(pdl->schema);
if ( pdl->bytes )
{
for ( i = 0; i < pdl->schema->ndims; i++ )
pc_bytes_free(pdl->bytes[i]);
pcfree(pdl->bytes);
}
pcfree(pdl);
}
/* Setup/teardown for this suite */
static int
init_suite(void)
{
char *xmlstr = file_to_str(xmlfile);
int rv = pc_schema_from_xml(xmlstr, &schema);
pcfree(xmlstr);
return rv == PC_FAILURE ? -1 : 0;
}
static void
test_patch_wkb()
{
int i;
int npts = 20;
PCPOINTLIST *pl1;
PCPATCH_UNCOMPRESSED *pu1, *pu2;
PCPATCH *pa1, *pa2, *pa3, *pa4;
PCDIMSTATS *pds = NULL;
size_t z1, z2;
uint8_t *wkb1, *wkb2;
char *str;
pl1 = pc_pointlist_make(npts);
for ( i = 0; i < npts; i++ )
{
PCPOINT *pt = pc_point_make(simpleschema);
pc_point_set_double_by_name(pt, "x", i*2.123);
pc_point_set_double_by_name(pt, "y", i*2.9);
pc_point_set_double_by_name(pt, "Z", i*0.3099);
pc_point_set_double_by_name(pt, "intensity", 13);
pc_pointlist_add_point(pl1, pt);
}
pa1 = (PCPATCH*)pc_patch_dimensional_from_pointlist(pl1);
wkb1 = pc_patch_to_wkb(pa1, &z1);
str = hexbytes_from_bytes(wkb1, z1);
// printf("str\n%s\n",str);
pa2 = pc_patch_from_wkb(simpleschema, wkb1, z1);
// printf("pa2\n%s\n",pc_patch_to_string(pa2));
pa3 = pc_patch_compress(pa2, NULL);
// printf("pa3\n%s\n",pc_patch_to_string(pa3));
wkb2 = pc_patch_to_wkb(pa3, &z2);
pa4 = pc_patch_from_wkb(simpleschema, wkb2, z2);
// printf("pa4\n%s\n",pc_patch_to_string(pa4));
pu1 = (PCPATCH_UNCOMPRESSED*)pc_patch_uncompressed_from_dimensional((PCPATCH_DIMENSIONAL*)pa1);
pu2 = (PCPATCH_UNCOMPRESSED*)pc_patch_uncompressed_from_dimensional((PCPATCH_DIMENSIONAL*)pa4);
// printf("pu1\n%s\n", pc_patch_to_string((PCPATCH*)pu1));
// printf("pu2\n%s\n", pc_patch_to_string((PCPATCH*)pu2));
CU_ASSERT_EQUAL(pu1->datasize, pu2->datasize);
CU_ASSERT_EQUAL(pu1->npoints, pu2->npoints);
CU_ASSERT(memcmp(pu1->data, pu2->data, pu1->datasize) == 0);
pc_pointlist_free(pl1);
pc_patch_free(pa1);
pc_patch_free(pa2);
pcfree(wkb1);
}
static void
test_sort_consistency()
{
// 00 endian (big)
// 00000000 pcid
// 00000000 compression
// 00000002 npoints
// 0000000800000003000000050006 pt1 (XYZi)
// 0000000200000001000000040008 pt2 (XYZi)
// init data
PCPATCH *pasort;
char *pastr, *pasortstr;
uint8_t *wkbsort;
char *hexbuf = "0000000000000000000000000200000008000000030000000500060000000200000001000000040008";
size_t hexsize = strlen(hexbuf);
uint8_t *wkb = bytes_from_hexbytes(hexbuf, hexsize);
PCPATCH *pa = pc_patch_from_wkb(schema, wkb, hexsize/2);
PCPOINTLIST *li = pc_pointlist_from_patch(pa);
const char *X[] = {"X"};
// sort on X attribute
pasort = pc_patch_sort(pa, X, 1);
//chek consistency
wkbsort = pc_patch_to_wkb(pasort, &hexsize);
CU_ASSERT_EQUAL(wkb_get_pcid(wkb), wkb_get_pcid(wkbsort));
CU_ASSERT_EQUAL(wkb_get_npoints(wkb), wkb_get_npoints(wkbsort));
CU_ASSERT_EQUAL(wkb_get_compression(wkb), wkb_get_compression(wkbsort));
pastr = pc_patch_to_string(pa);
CU_ASSERT_STRING_EQUAL(pastr, "{\"pcid\":0,\"pts\":[[0.08,0.03,0.05,6],[0.02,0.01,0.04,8]]}");
pasortstr = pc_patch_to_string(pasort);
CU_ASSERT_STRING_EQUAL(pasortstr, "{\"pcid\":0,\"pts\":[[0.02,0.01,0.04,8],[0.08,0.03,0.05,6]]}");
// free
pcfree(wkb);
pcfree(wkbsort);
pcfree(pastr);
pcfree(pasortstr);
pc_patch_free(pasort);
pc_patch_free(pa);
pc_pointlist_free(li);
}
