/* * 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 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 cu_wkb_in(char *wkt) { LWGEOM_PARSER_RESULT pr; LWGEOM *g_a, *g_b; uint8_t *wkb_a, *wkb_b; size_t wkb_size_a, wkb_size_b; /* int i; char *hex; */ if ( hex_a ) free(hex_a); if ( hex_b ) free(hex_b); /* Turn WKT into geom */ lwgeom_parse_wkt(&pr, wkt, LW_PARSER_CHECK_NONE); if ( pr.errcode ) { printf("ERROR: %s\n", pr.message); printf("POSITION: %d\n", pr.errlocation); exit(0); } /* Get the geom */ g_a = pr.geom; /* Turn geom into WKB */ wkb_a = lwgeom_to_wkb(g_a, WKB_NDR | WKB_EXTENDED, &wkb_size_a); /* Turn WKB back into geom */ g_b = lwgeom_from_wkb(wkb_a, wkb_size_a, LW_PARSER_CHECK_NONE); /* Turn geom to WKB again */ wkb_b = lwgeom_to_wkb(g_b, WKB_NDR | WKB_EXTENDED, &wkb_size_b); /* Turn geoms into WKB for comparisons */ hex_a = hexbytes_from_bytes(wkb_a, wkb_size_a); hex_b = hexbytes_from_bytes(wkb_b, wkb_size_b); /* Clean up */ lwfree(wkb_a); lwfree(wkb_b); lwgeom_parser_result_free(&pr); lwgeom_free(g_b); }
char * pc_patch_to_hexwkb(const PCPATCH *patch) { uint8 *wkb; size_t wkb_size; char *hexwkb; wkb = pc_patch_to_wkb(patch, &wkb_size); hexwkb = hexbytes_from_bytes(wkb, wkb_size); pfree(wkb); return hexwkb; }
char * pc_point_to_hexwkb(const PCPOINT *pt) { uint8 *wkb; size_t wkb_size; char *hexwkb; wkb = pc_point_to_wkb(pt, &wkb_size); hexwkb = hexbytes_from_bytes(wkb, wkb_size); pfree(wkb); return hexwkb; }
static void test_ght_node_serialization(void) { GhtCoordinate coord; int x, y; GhtNode *node1, *node2, *node3; GhtErr err; GhtWriter *writer; GhtReader *reader; const uint8_t *bytes; size_t bytes_size; stringbuffer_t *sb1, *sb2; GhtAttribute *attr; char *hex; /* ght_node_new_from_coordinate(const GhtCoordinate *coord, unsigned int resolution, GhtNode **node); */ coord.x = -127.4123; coord.y = 49.23141; err = ght_node_new_from_coordinate(&coord, GHT_MAX_HASH_LENGTH, &node1); CU_ASSERT_STRING_EQUAL(node1->hash, "c0v2hdm1wpzpy4vtv4"); CU_ASSERT_EQUAL(err, GHT_OK); err = ght_writer_new_mem(&writer); err = ght_node_write(node1, writer); bytes = bytebuffer_getbytes(writer->bytebuffer); bytes_size = bytebuffer_getsize(writer->bytebuffer); err = ght_reader_new_mem(bytes, bytes_size, schema, &reader); err = ght_node_read(reader, &node2); CU_ASSERT_STRING_EQUAL(node1->hash, node2->hash); ght_node_free(node2); /* add a child */ coord.x = -127.4125; coord.y = 49.23144; err = ght_node_new_from_coordinate(&coord, GHT_MAX_HASH_LENGTH, &node3); err = ght_attribute_new_from_double(schema->dims[3], 88.88, &attr); err = ght_node_add_attribute(node3, attr); err = ght_node_insert_node(node1, node3, GHT_DUPES_YES); CU_ASSERT_EQUAL(err, GHT_OK); /* add another (dupe) child */ err = ght_node_new_from_coordinate(&coord, GHT_MAX_HASH_LENGTH, &node3); err = ght_node_insert_node(node1, node3, GHT_DUPES_YES); /* add another (dupe) child with an attribute */ err = ght_node_new_from_coordinate(&coord, GHT_MAX_HASH_LENGTH, &node3); err = ght_attribute_new_from_double(schema->dims[2], 99.99, &attr); err = ght_node_add_attribute(node3, attr); err = ght_node_insert_node(node1, node3, GHT_DUPES_YES); sb1 = stringbuffer_create(); err = ght_node_to_string(node1, sb1, 0); // printf("ORIGINAL\n%s\n", stringbuffer_getstring(sb1)); err = ght_writer_new_mem(&writer); err = ght_node_write(node1, writer); bytes = bytebuffer_getbytes(writer->bytebuffer); bytes_size = bytebuffer_getsize(writer->bytebuffer); err = hexbytes_from_bytes(bytes, bytes_size, &hex); CU_ASSERT_STRING_EQUAL("086330763268646D3100020A77707A7079347674763400000A6374643463637839796201035800020000000001020F27000000", hex); // printf("\n\n%s\n", hex); err = ght_reader_new_mem(bytes, bytes_size, schema, &reader); err = ght_node_read(reader, &node2); sb2 = stringbuffer_create(); err = ght_node_to_string(node2, sb2, 0); // printf("COPY\n%s\n", stringbuffer_getstring(sb2)); CU_ASSERT_STRING_EQUAL(stringbuffer_getstring(sb1), stringbuffer_getstring(sb2)); stringbuffer_destroy(sb2); stringbuffer_destroy(sb1); ght_node_free(node1); ght_node_free(node2); ght_writer_free(writer); ght_reader_free(reader); }
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); }