/* * 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); }
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_point_access() { PCPOINT *pt; int rv; double a1, a2, a3, a4, b1, b2, b3, b4; int idx = 0; pt = pc_point_make(schema); CU_ASSERT( pt != NULL ); /* One at a time */ idx = 0; a1 = 1.5; rv = pc_point_set_double_by_index(pt, idx, a1); rv = 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; rv = pc_point_set_double_by_index(pt, idx, a2); rv = pc_point_get_double_by_index(pt, idx, &b2); CU_ASSERT_DOUBLE_EQUAL(a2, b2, 0.0000001); a3 = 91; rv = pc_point_set_double_by_name(pt, "NumberOfReturns", a3); rv = pc_point_get_double_by_name(pt, "NumberOfReturns", &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; rv = pc_point_set_double_by_index(pt, 0, a1); rv = pc_point_set_double_by_index(pt, 2, a2); rv = pc_point_set_double_by_name(pt, "NumberOfReturns", a3); rv = pc_point_set_double_by_name(pt, "UserData", a4); rv = pc_point_get_double_by_index(pt, 0, &b1); rv = pc_point_get_double_by_index(pt, 2, &b2); rv = pc_point_get_double_by_name(pt, "NumberOfReturns", &b3); rv = pc_point_get_double_by_name(pt, "UserData", &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); pc_point_free(pt); }
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); }
Datum pcpoint_from_double_array(PG_FUNCTION_ARGS) { uint32 pcid = PG_GETARG_INT32(0); ArrayType *arrptr = PG_GETARG_ARRAYTYPE_P(1); int nelems; float8 *vals; PCPOINT *pt; PCSCHEMA *schema = pc_schema_from_pcid(pcid, fcinfo); SERIALIZED_POINT *serpt; if ( ! schema ) elog(ERROR, "unable to load schema for pcid = %d", pcid); if ( ARR_ELEMTYPE(arrptr) != FLOAT8OID ) elog(ERROR, "array must be of float8[]"); if ( ARR_NDIM(arrptr) != 1 ) elog(ERROR, "float8[] must have only one dimension"); if ( ARR_HASNULL(arrptr) ) elog(ERROR, "float8[] must not have null elements"); nelems = ARR_DIMS(arrptr)[0]; if ( nelems != schema->ndims || ARR_LBOUND(arrptr)[0] > 1 ) elog(ERROR, "array dimensions do not match schema dimensions of pcid = %d", pcid); vals = (float8*) ARR_DATA_PTR(arrptr); pt = pc_point_from_double_array(schema, vals, nelems); serpt = pc_point_serialize(pt); pc_point_free(pt); PG_RETURN_POINTER(serpt); }
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); }
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); }
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); }
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 = pc_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 = pc_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); }
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; }
Datum pcpoint_get_value(PG_FUNCTION_ARGS) { SERIALIZED_POINT *serpt = PG_GETARG_SERPOINT_P(0); text *dim_name = PG_GETARG_TEXT_P(1); char *dim_str; float8 double_result; PCSCHEMA *schema = pc_schema_from_pcid(serpt->pcid, fcinfo); PCPOINT *pt = pc_point_deserialize(serpt, schema); if ( ! pt ) PG_RETURN_NULL(); dim_str = text_to_cstring(dim_name); if ( ! pc_point_get_double_by_name(pt, dim_str, &double_result) ) { pc_point_free(pt); elog(ERROR, "dimension \"%s\" does not exist in schema", dim_str); } pfree(dim_str); pc_point_free(pt); PG_RETURN_DATUM(DirectFunctionCall1(float8_numeric, Float8GetDatum(double_result))); }
static void test_patch_set_schema_dimensional_compression(enum DIMCOMPRESSIONS dimcomp) { // init data PCPATCH_DIMENSIONAL *padim1, *padim2; PCPATCH *pat; PCPOINT *pt; PCPOINTLIST *pl; char *str; int i; int npts = PCDIMSTATS_MIN_SAMPLE+1; // force to keep custom compression // 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); } padim1 = pc_patch_dimensional_from_pointlist(pl); // set dimensional compression for each dimension PCDIMSTATS *stats = pc_dimstats_make(simpleschema); pc_dimstats_update(stats, padim1); for ( i = 0; i<padim1->schema->ndims; i++ ) stats->stats[i].recommended_compression = dimcomp; // compress patch padim2 = pc_patch_dimensional_compress(padim1, stats); // assign a valid schema to the patch pat = pc_patch_set_schema((PCPATCH*) padim2, simpleschema_nointensity, 0.0); CU_ASSERT(pat != NULL); pt = pc_patch_pointn(pat, 1); str = pc_point_to_string(pt); CU_ASSERT_STRING_EQUAL(str,"{\"pcid\":0,\"pt\":[1000.1,2000.2,3000.3]}"); pcfree(str); pc_point_free(pt); pc_patch_free(pat); pc_pointlist_free(pl); pc_dimstats_free(stats); pc_patch_free((PCPATCH *)padim1); pc_patch_free((PCPATCH *)padim2); }
Datum pcpoint_out(PG_FUNCTION_ARGS) { PCPOINT *pcpt = NULL; PCSCHEMA *schema = NULL; SERIALIZED_POINT *serpt = NULL; char *hexwkb = NULL; serpt = PG_GETARG_SERPOINT_P(0); schema = pc_schema_from_pcid(serpt->pcid, fcinfo); pcpt = pc_point_deserialize(serpt, schema); hexwkb = pc_point_to_hexwkb(pcpt); pc_point_free(pcpt); PG_RETURN_CSTRING(hexwkb); }
Datum pcpoint_as_text(PG_FUNCTION_ARGS) { SERIALIZED_POINT *serpt = PG_GETARG_SERPOINT_P(0); text *txt; char *str; PCSCHEMA *schema = pc_schema_from_pcid(serpt->pcid, fcinfo); PCPOINT *pt = pc_point_deserialize(serpt, schema); if ( ! pt ) PG_RETURN_NULL(); str = pc_point_to_string(pt); pc_point_free(pt); txt = cstring_to_text(str); pfree(str); PG_RETURN_TEXT_P(txt); }
Datum pcpoint_in(PG_FUNCTION_ARGS) { char *str = PG_GETARG_CSTRING(0); /* Datum pc_oid = PG_GETARG_OID(1); Not needed. */ int32 typmod = 0; uint32 pcid = 0; PCPOINT *pt; SERIALIZED_POINT *serpt = NULL; if ( (PG_NARGS()>2) && (!PG_ARGISNULL(2)) ) { typmod = PG_GETARG_INT32(2); pcid = pcid_from_typmod(typmod); } /* Empty string. */ if ( str[0] == '\0' ) { ereport(ERROR,(errmsg("pcpoint parse error - empty string"))); } /* Binary or text form? Let's find out. */ if ( str[0] == '0' ) { /* Hex-encoded binary */ pt = pc_point_from_hexwkb(str, strlen(str), fcinfo); pcid_consistent(pt->schema->pcid, pcid); serpt = pc_point_serialize(pt); pc_point_free(pt); } else { ereport(ERROR,(errmsg("parse error - support for text format not yet implemented"))); } if ( serpt ) PG_RETURN_POINTER(serpt); else PG_RETURN_NULL(); }
Datum pcpoint_as_bytea(PG_FUNCTION_ARGS) { SERIALIZED_POINT *serpt = PG_GETARG_SERPOINT_P(0); uint8 *bytes; size_t bytes_size; bytea *wkb; size_t wkb_size; PCSCHEMA *schema = pc_schema_from_pcid(serpt->pcid, fcinfo); PCPOINT *pt = pc_point_deserialize(serpt, schema); if ( ! pt ) PG_RETURN_NULL(); bytes = pc_point_to_geometry_wkb(pt, &bytes_size); wkb_size = VARHDRSZ + bytes_size; wkb = palloc(wkb_size); memcpy(VARDATA(wkb), bytes, bytes_size); SET_VARSIZE(wkb, wkb_size); pc_point_free(pt); pfree(bytes); PG_RETURN_BYTEA_P(wkb); }
static void test_point_access() { PCPOINT *pt; int rv; double a1, a2, a3, a4, b1, b2, b3, b4; int idx = 0; double *allvals; pt = pc_point_make(schema); CU_ASSERT( pt != NULL ); /* One at a time */ idx = 0; a1 = 1.5; rv = pc_point_set_double_by_index(pt, idx, a1); rv = 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; rv = pc_point_set_double_by_index(pt, idx, a2); rv = pc_point_get_double_by_index(pt, idx, &b2); CU_ASSERT_DOUBLE_EQUAL(a2, b2, 0.0000001); a3 = 91; rv = pc_point_set_double_by_name(pt, "Intensity", a3); rv = 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; rv = pc_point_set_double_by_index(pt, 0, a1); rv = pc_point_set_double_by_index(pt, 1, a2); rv = pc_point_set_double_by_name(pt, "Intensity", a3); rv = pc_point_set_double_by_name(pt, "Z", a4); rv = pc_point_get_double_by_index(pt, 0, &b1); rv = pc_point_get_double_by_index(pt, 1, &b2); rv = pc_point_get_double_by_name(pt, "Intensity", &b3); rv = 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 */ rv = pc_point_set_double_by_index(pt, 0, a1); rv = pc_point_set_double_by_index(pt, 1, a2); rv = pc_point_set_double_by_index(pt, 2, a3); rv = 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); }
static void test_patch_transform_compression_none() { // init data PCPATCH_UNCOMPRESSED *pau; PCSCHEMA *nschema; PCPOINTLIST *pl; PCPATCH *pa; PCPOINT *pt; char *str; int i; int npts = 5; uint8_t *wkb; size_t wkbsize; // build a patch pl = pc_pointlist_make(npts); for ( i = (npts - 1); 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); } pau = pc_patch_uncompressed_from_pointlist(pl); // create a new schema, and use 0.02 scale values for x, y and z nschema = pc_schema_clone(simpleschema); nschema->xdim->scale = 0.02; nschema->ydim->scale = 0.02; nschema->zdim->scale = 0.02; // transform the patch pa = pc_patch_transform((PCPATCH*) pau, nschema, 0.0); CU_ASSERT(pa != NULL); // check point 1 // expected: x=hex(20)=0x14, y=hex(40)=0x28, z=hex(60)=0x3C, I=hex(10)=0x0A pt = pc_patch_pointn(pa, 1); wkb = pc_point_to_wkb(pt, &wkbsize); str = hexbytes_from_bytes(wkb, wkbsize); CU_ASSERT_STRING_EQUAL(str, "010000000014000000280000003C0000000A00"); pcfree(str); pcfree(wkb); pc_point_free(pt); // check point 2 // expected: x=hex(15)=0x0F, y=hex(30)=0x1E, z=hex(45)=0x2D, I=hex(10)=0x0A pt = pc_patch_pointn(pa, 2); wkb = pc_point_to_wkb(pt, &wkbsize); str = hexbytes_from_bytes(wkb, wkbsize); CU_ASSERT_STRING_EQUAL(str, "01000000000F0000001E0000002D0000000A00"); pcfree(str); pcfree(wkb); pc_point_free(pt); // check point 3 // expected: x=hex(10)=0x0A, y=hex(20)=0x14, z=hex(30)=0x1E, I=hex(10)=0x0A pt = pc_patch_pointn(pa, 3); wkb = pc_point_to_wkb(pt, &wkbsize); str = hexbytes_from_bytes(wkb, wkbsize); CU_ASSERT_STRING_EQUAL(str, "01000000000A000000140000001E0000000A00"); pcfree(str); pcfree(wkb); pc_point_free(pt); // check point 4 // expected: x=hex(5)=0x05, y=hex(10)=0x0A, z=hex(15)=0x0F, I=hex(10)=0x0A pt = pc_patch_pointn(pa, 4); wkb = pc_point_to_wkb(pt, &wkbsize); str = hexbytes_from_bytes(wkb, wkbsize); CU_ASSERT_STRING_EQUAL(str, "0100000000050000000A0000000F0000000A00"); pcfree(str); pcfree(wkb); pc_point_free(pt); // check point 5 // expected: x=hex(0)=0x00, y=hex(0)=0x00, z=hex(0)=0x00, I=hex(10)=0x0A pt = pc_patch_pointn(pa, 5); wkb = pc_point_to_wkb(pt, &wkbsize); str = hexbytes_from_bytes(wkb, wkbsize); CU_ASSERT_STRING_EQUAL(str, "01000000000000000000000000000000000A00"); pcfree(str); pcfree(wkb); pc_point_free(pt); pc_patch_free(pa); pc_schema_free(nschema); pc_patch_free((PCPATCH*) pau); pc_pointlist_free(pl); }