mirror of
https://github.com/pgpointcloud/pointcloud.git
synced 2025-12-08 20:36:04 +00:00
338 lines
9.9 KiB
C
338 lines
9.9 KiB
C
/***********************************************************************
|
|
* cu_pc_schema.c
|
|
*
|
|
* Testing for the schema API functions
|
|
*
|
|
* Portions Copyright (c) 2012, OpenGeo
|
|
*
|
|
***********************************************************************/
|
|
|
|
#include "CUnit/Basic.h"
|
|
#include "cu_tester.h"
|
|
|
|
/* GLOBALS ************************************************************/
|
|
|
|
static PCSCHEMA *schema = NULL;
|
|
static PCSCHEMA *schema_xy = NULL;
|
|
static PCSCHEMA *schema_xyz = NULL;
|
|
static PCSCHEMA *schema_xym = NULL;
|
|
static PCSCHEMA *schema_xyzm = NULL;
|
|
static const char *xmlfile = "data/simple-schema.xml";
|
|
static const char *xmlfile_xy = "data/simple-schema-xy.xml";
|
|
static const char *xmlfile_xyz = "data/simple-schema-xyz.xml";
|
|
static const char *xmlfile_xym = "data/simple-schema-xym.xml";
|
|
static const char *xmlfile_xyzm = "data/simple-schema-xyzm.xml";
|
|
|
|
// SIMPLE SCHEMA
|
|
// int32_t x
|
|
// int32_t y
|
|
// int32_t z
|
|
// int16_t intensity
|
|
|
|
/* 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 int
|
|
clean_suite(void)
|
|
{
|
|
pc_schema_free(schema);
|
|
pc_schema_free(schema_xy);
|
|
pc_schema_free(schema_xyz);
|
|
pc_schema_free(schema_xym);
|
|
pc_schema_free(schema_xyzm);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* TESTS **************************************************************/
|
|
|
|
static void
|
|
test_point_hex_inout()
|
|
{
|
|
// byte: endianness (1 = NDR, 0 = XDR)
|
|
// uint32: pcid (key to POINTCLOUD_SCHEMAS)
|
|
// uchar[]: pointdata (interpret relative to pcid)
|
|
|
|
double d;
|
|
char *hexbuf = "00000000010000000100000002000000030004";
|
|
size_t hexsize = strlen(hexbuf);
|
|
uint8_t *wkb = bytes_from_hexbytes(hexbuf, hexsize);
|
|
PCPOINT *pt = pc_point_from_wkb(schema, wkb, hexsize/2);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "X", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 0.01, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Y", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 0.02, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Z", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 0.03, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Intensity", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 4, 0.0001);
|
|
CU_ASSERT_FAILURE(pc_point_get_double_by_name(pt, "M", &d));
|
|
pc_point_free(pt);
|
|
pcfree(wkb);
|
|
|
|
hexbuf = "01010000000100000002000000030000000500";
|
|
hexsize = strlen(hexbuf);
|
|
wkb = bytes_from_hexbytes(hexbuf, hexsize);
|
|
pt = pc_point_from_wkb(schema, wkb, hexsize/2);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "X", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 0.01, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Y", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 0.02, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Z", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 0.03, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Intensity", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, 5, 0.0001);
|
|
CU_ASSERT_FAILURE(pc_point_get_double_by_name(pt, "M", &d));
|
|
pc_point_free(pt);
|
|
pcfree(wkb);
|
|
|
|
}
|
|
|
|
static void
|
|
test_point_access()
|
|
{
|
|
PCPOINT *pt;
|
|
double a1, a2, a3, a4, b1, b2, b3, b4;
|
|
int idx = 0;
|
|
double *allvals;
|
|
|
|
pt = pc_point_make(schema);
|
|
CU_ASSERT_PTR_NOT_NULL( pt );
|
|
|
|
/* One at a time */
|
|
idx = 0;
|
|
a1 = 1.5;
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_index(pt, idx, a1));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_index(pt, idx, &b1));
|
|
// printf("d1=%g, d2=%g\n", a1, b1);
|
|
CU_ASSERT_DOUBLE_EQUAL(a1, b1, 0.0000001);
|
|
|
|
idx = 2;
|
|
a2 = 1501500.12;
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_index(pt, idx, a2));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_index(pt, idx, &b2));
|
|
CU_ASSERT_DOUBLE_EQUAL(a2, b2, 0.0000001);
|
|
|
|
a3 = 91;
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_name(pt, "Intensity", a3));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Intensity", &b3));
|
|
CU_ASSERT_DOUBLE_EQUAL(a3, b3, 0.0000001);
|
|
|
|
pc_point_free(pt);
|
|
|
|
/* All at once */
|
|
pt = pc_point_make(schema);
|
|
a1 = 1.5;
|
|
a2 = 1501500.12;
|
|
a3 = 91;
|
|
a4 = 200;
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_index(pt, 0, a1));
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_index(pt, 1, a2));
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_name(pt, "Intensity", a3));
|
|
CU_ASSERT_SUCCESS(pc_point_set_double_by_name(pt, "Z", a4));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_index(pt, 0, &b1));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_index(pt, 1, &b2));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Intensity", &b3));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Z", &b4));
|
|
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);
|
|
|
|
/* as a double array */
|
|
pc_point_set_double_by_index(pt, 0, a1);
|
|
pc_point_set_double_by_index(pt, 1, a2);
|
|
pc_point_set_double_by_index(pt, 2, a3);
|
|
pc_point_set_double_by_index(pt, 3, a4);
|
|
allvals = pc_point_to_double_array(pt);
|
|
CU_ASSERT_DOUBLE_EQUAL(allvals[0], a1, 0.0000001);
|
|
CU_ASSERT_DOUBLE_EQUAL(allvals[1], a2, 0.0000001);
|
|
//printf("allvals[2]:%g\n", allvals[2]);
|
|
CU_ASSERT_DOUBLE_EQUAL(allvals[2], a3, 0.0000001);
|
|
//printf("allvals[3]:%g\n", allvals[3]);
|
|
CU_ASSERT_DOUBLE_EQUAL(allvals[3], a4, 0.0000001);
|
|
pcfree(allvals);
|
|
|
|
pc_point_free(pt);
|
|
|
|
}
|
|
|
|
static void
|
|
test_point_xyzm()
|
|
{
|
|
PCPOINT *pt;
|
|
double x = 1;
|
|
double y = 40;
|
|
double z = 160;
|
|
double m = 640;
|
|
double d;
|
|
|
|
pt = pc_point_make(schema_xyz);
|
|
CU_ASSERT_PTR_NOT_NULL( pt );
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_x(pt, x));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "X", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, x, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_x(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, x, 0.000001);
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_y(pt, y));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Y", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, y, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_y(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, y, 0.000001);
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_z(pt, z));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Z", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, z, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_z(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, z, 0.000001);
|
|
|
|
CU_ASSERT_FAILURE(pc_point_set_m(pt, m));
|
|
CU_ASSERT_FAILURE(pc_point_get_double_by_name(pt, "M", &d));
|
|
CU_ASSERT_FAILURE(pc_point_get_m(pt, &d));
|
|
|
|
pc_point_free(pt);
|
|
|
|
pt = pc_point_make(schema_xyzm);
|
|
CU_ASSERT_PTR_NOT_NULL( pt );
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_x(pt, x));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "X", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, x, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_x(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, x, 0.000001);
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_y(pt, y));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Y", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, y, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_y(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, y, 0.000001);
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_z(pt, z));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "Z", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, z, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_z(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, z, 0.000001);
|
|
|
|
CU_ASSERT_SUCCESS(pc_point_set_m(pt, m));
|
|
CU_ASSERT_SUCCESS(pc_point_get_double_by_name(pt, "M", &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, m, 0.000001);
|
|
CU_ASSERT_SUCCESS(pc_point_get_m(pt, &d));
|
|
CU_ASSERT_DOUBLE_EQUAL(d, m, 0.000001);
|
|
|
|
pc_point_free(pt);
|
|
}
|
|
|
|
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 = 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 = hexbytes_from_bytes(geomwkb,geomwkbsize);
|
|
CU_ASSERT_STRING_EQUAL(geomhexbytes, expectedgeomhexbytes);
|
|
|
|
pcfree(geomhexbytes);
|
|
pcfree(geomwkb);
|
|
pc_point_free(pt);
|
|
pcfree(ptwkb);
|
|
}
|
|
|
|
|
|
static void
|
|
test_point_geometry()
|
|
{
|
|
// pt XYI = 1 2 3, scale = 1 2 1, geom XY = 1 4
|
|
test_point_geometry_bytes(schema_xy, 5+2*8,
|
|
"000000000100000001000000020003",
|
|
"0101000000000000000000F03F0000000000001040"
|
|
);
|
|
|
|
// pt XYZI = 1 2 3 4, scale = 1 2 4 1, geom XYZ = 1 2 3
|
|
test_point_geometry_bytes(schema_xyz, 5+3*8,
|
|
"00000000010000000100000002000000030004",
|
|
"0101000080000000000000F03F00000000000010400000000000002840"
|
|
);
|
|
|
|
// pt XYMI = 1 2 3 4, scale = 1 2 4 1, geom XYM = 1 4 12
|
|
test_point_geometry_bytes(schema_xym, 5+3*8,
|
|
"00000000010000000100000002000000030004",
|
|
"0101000040000000000000F03F00000000000010400000000000002840"
|
|
);
|
|
|
|
// pt XYZMI = 1 2 3 4 5, scale = 1 2 4 8 1, geom XYZM = 1 4 12 32
|
|
test_point_geometry_bytes(schema_xyzm, 5+4*8,
|
|
"0000000001000000010000000200000003000000040005",
|
|
"01010000C0000000000000F03F000000000000104000000000000028400000000000004040"
|
|
);
|
|
|
|
}
|
|
|
|
/* REGISTER ***********************************************************/
|
|
|
|
CU_TestInfo point_tests[] = {
|
|
PC_TEST(test_point_hex_inout),
|
|
PC_TEST(test_point_access),
|
|
PC_TEST(test_point_xyzm),
|
|
PC_TEST(test_point_geometry),
|
|
CU_TEST_INFO_NULL
|
|
};
|
|
|
|
CU_SuiteInfo point_suite = {
|
|
.pName = "point",
|
|
.pInitFunc = init_suite,
|
|
.pCleanupFunc = clean_suite,
|
|
.pTests = point_tests
|
|
};
|