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_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; }
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_patch_is_sorted_compression_dimensional(enum DIMCOMPRESSIONS dimcomp) { // init data PCPATCH_DIMENSIONAL *padim1, *padim2, *padimsort; PCPOINT *pt; PCPOINTLIST *pl; int i; int ndims = 1; int npts = PCDIMSTATS_MIN_SAMPLE+1; // force to keep custom compression const char *X[] = {"X"}; // build a dimensional patch pl = pc_pointlist_make(npts); for ( i = npts; i >= 0; i-- ) { pt = pc_point_make(schema); 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); 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(schema); 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); // test that patch is not sorted CU_ASSERT_EQUAL(pc_patch_is_sorted((PCPATCH*) padim2, X, ndims, PC_FALSE), PC_FALSE); CU_ASSERT_EQUAL(pc_patch_is_sorted((PCPATCH*) padim2, X, ndims, PC_TRUE), PC_FALSE); // sort padimsort = (PCPATCH_DIMENSIONAL*) pc_patch_sort((PCPATCH*) padim2, X, 1); // test that resulting data is sorted CU_ASSERT_EQUAL(pc_patch_is_sorted((PCPATCH*) padimsort, X, ndims, PC_TRUE), PC_TRUE); // free pc_dimstats_free(stats); pc_patch_free((PCPATCH *)padim1); pc_patch_free((PCPATCH *)padim2); pc_patch_free((PCPATCH *)padimsort); pc_pointlist_free(pl); }
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); }
/** * Pivot a pointlist into a dimlist and back. * Test for data loss or alteration. */ static void test_patch_dimensional() { PCPOINT *pt; int i; int npts = 10; PCPOINTLIST *pl1, *pl2; PCPATCH_DIMENSIONAL *pdl; PCDIMSTATS *pds; 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); } pdl = pc_patch_dimensional_from_pointlist(pl1); pl2 = pc_pointlist_from_dimensional(pdl); for ( i = 0; i < npts; i++ ) { pt = pc_pointlist_get_point(pl2, i); double v1, v2, v3, v4; pc_point_get_double_by_name(pt, "x", &v1); pc_point_get_double_by_name(pt, "y", &v2); pc_point_get_double_by_name(pt, "Z", &v3); pc_point_get_double_by_name(pt, "intensity", &v4); // printf("%g\n", v4); CU_ASSERT_DOUBLE_EQUAL(v1, i*2.0, 0.001); CU_ASSERT_DOUBLE_EQUAL(v2, i*1.9, 0.001); CU_ASSERT_DOUBLE_EQUAL(v3, i*0.34, 0.001); CU_ASSERT_DOUBLE_EQUAL(v4, 10, 0.001); } pds = pc_dimstats_make(simpleschema); pc_dimstats_update(pds, pdl); pc_dimstats_update(pds, pdl); pc_patch_free((PCPATCH*)pdl); pc_pointlist_free(pl1); pc_pointlist_free(pl2); pc_dimstats_free(pds); }
static void test_patch_range_compression_dimensional(enum DIMCOMPRESSIONS dimcomp) { int i; PCPOINTLIST *pl; PCPATCH *pa; PCPATCH *par; PCPATCH_DIMENSIONAL *pad; PCPOINT *pt; char *str; int npts = PCDIMSTATS_MIN_SAMPLE+1; // force to keep custom compression // build a dimensional 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); pc_point_set_double_by_name(pt, "Y", i); pc_point_set_double_by_name(pt, "Z", i); pc_point_set_double_by_name(pt, "Intensity", 10); pc_pointlist_add_point(pl, pt); } pad = pc_patch_dimensional_from_pointlist(pl); // set dimensional compression for each dimension PCDIMSTATS *stats = pc_dimstats_make(simpleschema); pc_dimstats_update(stats, pad); for ( i = 0; i<pad->schema->ndims; i++ ) stats->stats[i].recommended_compression = dimcomp; // compress patch pa = (PCPATCH*) pc_patch_dimensional_compress(pad, stats); par = pc_patch_range(pa, 16, 4); str = pc_patch_to_string(par); CU_ASSERT_STRING_EQUAL(str, "{\"pcid\":0,\"pts\":[[9986,9986,9986,10],[9985,9985,9985,10],[9984,9984,9984,10],[9983,9983,9983,10]]}"); pcfree(str); pc_patch_free(par); pc_patch_free((PCPATCH *)pad); pc_dimstats_free(stats); pc_patch_free(pa); pc_pointlist_free(pl); }
static void test_patch_dimensional_extent() { PCPOINT *pt; int i, rv; int npts = 2; PCPOINTLIST *pl1; PCPATCH_DIMENSIONAL *pch1; pl1 = pc_pointlist_make(npts); for ( i = 1; i <= npts; i++ ) { pt = pc_point_make(simpleschema); pc_point_set_double_by_name(pt, "x", 5+i*1); pc_point_set_double_by_name(pt, "y", -i*10); pc_point_set_double_by_name(pt, "Z", i*0.2); pc_point_set_double_by_name(pt, "intensity", -5); pc_pointlist_add_point(pl1, pt); } pch1 = pc_patch_dimensional_from_pointlist(pl1); CU_ASSERT_EQUAL(pch1->bounds.xmin, 6); CU_ASSERT_EQUAL(pch1->bounds.xmax, 7); CU_ASSERT_EQUAL(pch1->bounds.ymin, -20); CU_ASSERT_EQUAL(pch1->bounds.ymax, -10); rv = pc_patch_dimensional_compute_extent(pch1); CU_ASSERT_EQUAL(rv, PC_SUCCESS); CU_ASSERT_EQUAL(pch1->bounds.xmin, 6); CU_ASSERT_EQUAL(pch1->bounds.xmax, 7); CU_ASSERT_EQUAL(pch1->bounds.ymin, -20); CU_ASSERT_EQUAL(pch1->bounds.ymax, -10); pc_patch_free((PCPATCH*)pch1); pc_pointlist_free(pl1); }
static void test_patch_dimensional_compression() { PCPOINT *pt; int i; int npts = 400; PCPOINTLIST *pl1, *pl2; PCPATCH_DIMENSIONAL *pch1, *pch2; PCDIMSTATS *pds = NULL; //size_t z1, z2; char *str; 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); } pch1 = pc_patch_dimensional_from_pointlist(pl1); // z1 = pc_patch_dimensional_serialized_size(pch1); // printf("z1 %ld\n", z1); pds = pc_dimstats_make(simpleschema); pc_dimstats_update(pds, pch1); pc_dimstats_update(pds, pch1); pch2 = pc_patch_dimensional_compress(pch1, pds); // z2 = pc_patch_dimensional_serialized_size(pch2); // printf("z2 %ld\n", z2); str = pc_dimstats_to_string(pds); CU_ASSERT_STRING_EQUAL(str, "{\"ndims\":4,\"total_points\":1200,\"total_patches\":3,\"dims\":[{\"total_runs\":1200,\"total_commonbits\":45,\"recommended_compression\":2},{\"total_runs\":1200,\"total_commonbits\":45,\"recommended_compression\":2},{\"total_runs\":1200,\"total_commonbits\":54,\"recommended_compression\":2},{\"total_runs\":3,\"total_commonbits\":48,\"recommended_compression\":1}]}"); // printf("%s\n", str); pcfree(str); pl2 = pc_pointlist_from_dimensional(pch2); for ( i = 0; i < npts; i++ ) { pt = pc_pointlist_get_point(pl2, i); double v1, v2, v3, v4; pc_point_get_double_by_name(pt, "x", &v1); pc_point_get_double_by_name(pt, "y", &v2); pc_point_get_double_by_name(pt, "Z", &v3); pc_point_get_double_by_name(pt, "intensity", &v4); // printf("%g\n", v4); CU_ASSERT_DOUBLE_EQUAL(v1, i*2.0, 0.001); CU_ASSERT_DOUBLE_EQUAL(v2, i*1.9, 0.001); CU_ASSERT_DOUBLE_EQUAL(v3, i*0.34, 0.001); CU_ASSERT_DOUBLE_EQUAL(v4, 10, 0.001); } pc_patch_free((PCPATCH*)pch1); pc_patch_free((PCPATCH*)pch2); pc_pointlist_free(pl1); pc_pointlist_free(pl2); if ( pds ) pc_dimstats_free(pds); }
/** * Test the function which clone a patch keeping only a part of dimensions, numerous print to see what happens */ static void test_patch_subset() { int i; int npts = 20; PCPOINTLIST *pl1,*pl2 ; PCPATCH_UNCOMPRESSED *pu1, *pu2; PCPATCH *pa1, *pa2, *pa3, *pa4; PCDIMSTATS *pds = NULL; size_t z1, z2; uint8_t *wkb1, *wkb2; char *str1; //getting a test patch 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*2.8); pc_point_set_double_by_name(pt1, "y", i*1.3); 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)); //testing the function : // printf("testing the dimension-reduction function\n"); //printf("\n\n position of x : %i \n\n",pc_schema_get_dimension_position_by_name(pa1->schema, "x")); uint32_t new_dim_number = 2; char *dim_to_keep[] = { "y", "x" }; uint32_t dim_position[2]; int i2 ; //test of pc_schema_get_dimension_position_by_name /* for(i2=0;i2<new_dim_number;i2++) { dim_position[i2] = pc_schema_get_dimension_position_by_name(pa1->schema, dim_to_keep[i2]); printf("\n dimension %s has position %d",dim_to_keep[i2],dim_position[i2] ); } printf("\n"); * */ //printf("\n the original schema to json : %s",pc_schema_to_json(pa1->schema)); //test of pc_bounds_to_string(PCBOUNDS *b) //testing the function pc_patch_dimensional_bytes_array_to_string //printf(" the original PCBYTES array :%s",pc_patch_dimensional_bytes_array_to_string((PCPATCH_DIMENSIONAL*)pa1)); //testing dimstat function : //creating dimstats //pds = pc_dimstats_make(simpleschema); //pc_dimstats_update(pds, (PCPATCH_DIMENSIONAL*)pa1); //testing function : //PCDIMSTATS * o_dimstats = pc_dimstats_clone_subset(pds,dim_position, new_dim_number); //testing reduce_dimension function //printf("\n \n beginning test of patch_reduce_dimension \n "); pa3 = pc_patch_reduce_dimension(pa1, dim_to_keep, new_dim_number); //printf("\n the schema to json : %s",pc_schema_to_json(pa3->schema)); // printf("\n the stats to json : %s",pc_stats_to_json(pa3->stats)); // printf("\n \n \n the patch to json : %s" , pc_patch_to_string(pa3)); //printf(" the pa3 PCBYTES array :%s",pc_patch_dimensional_bytes_array_to_string((PCPATCH_DIMENSIONAL*)pa3)); //test of the serialize / deserialize function to emulate the pc_acess top function //test on the result pathc : //test of pc_bounds_to_string(PCBOUNDS *b) //printf("the bounds of pa3 : %s \n", pc_bounds_to_string( &(pa3->bounds) ) ); //the test on result patch : should return a new patch with only Y and X dimension // printf("%s",pc_patch_to_string( pa3)); CU_ASSERT_STRING_EQUAL(pc_patch_to_string( pa3), "{\"pcid\":0,\"pts\":[[0,0],[1.3,2.8],[2.6,5.6],[3.9,8.4],[5.2,11.2],[6.5,14],[7.8,16.8],[9.1,19.6],[10.4,22.4],[11.7,25.2],[13,28],[14.3,30.8],[15.6,33.6],[16.9,36.4],[18.2,39.2],[19.5,42],[20.8,44.8],[22.1,47.6],[23.4,50.4],[24.7,53.2]]}"); return; //test on schema : printf("%s",pc_schema_to_json(pa3->schema )); printf("pa1\n%s\n", pc_patch_to_string(pa3)); //cleaning 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; }