archive-gh-me/pointcloud
1
0
Fork 0
mirror of https://github.com/pgpointcloud/pointcloud.git synced 2025-12-08 20:36:04 +00:00
Code Issues Projects Releases Wiki Activity

dim pointers instead of positions in PCSCHEMA

Browse Source 
replaces `int32_t x_position` with `PCDIMENSION *xdim` (and similarly for y,z,m) in PCSCHEMA to get a direct access to the corresponding dimension
-> code readability improvement by discarding the `-1` constant and maybe slight expected performance increase of get/set functions
This commit is contained in:
Mathieu Brédif 2017-02-23 11:38:11 +01:00
parent a6ceb504c3
commit 4088121eeb
6 changed files with 43 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/cunit/cu_pc_schema.c
View File

@ -201,13 +201,17 @@ test_schema_clone(void)
CU_ASSERT_EQUAL(clone->ndims, schema->ndims);
CU_ASSERT_EQUAL(clone->size, schema->size);
CU_ASSERT_EQUAL(clone->srid, schema->srid);
CU_ASSERT_EQUAL(clone->x_position, schema->x_position);
CU_ASSERT_EQUAL(clone->y_position, schema->y_position);
CU_ASSERT_EQUAL(clone->z_position, schema->z_position);
CU_ASSERT_EQUAL(clone->m_position, schema->m_position);
CU_ASSERT_EQUAL(clone->xdim->position, schema->xdim->position);
CU_ASSERT_EQUAL(clone->ydim->position, schema->ydim->position);
CU_ASSERT_EQUAL(clone->zdim->position, schema->zdim->position);
CU_ASSERT_EQUAL(clone->mdim->position, schema->mdim->position);
CU_ASSERT_EQUAL(clone->compression, schema->compression);
CU_ASSERT(clone->dims != schema->dims); /* deep clone */
CU_ASSERT(clone->namehash != schema->namehash); /* deep clone */
CU_ASSERT_NOT_EQUAL(clone->xdim, schema->xdim); /* deep clone */
CU_ASSERT_NOT_EQUAL(clone->ydim, schema->ydim); /* deep clone */
CU_ASSERT_NOT_EQUAL(clone->zdim, schema->zdim); /* deep clone */
CU_ASSERT_NOT_EQUAL(clone->mdim, schema->mdim); /* deep clone */
CU_ASSERT_NOT_EQUAL(clone->dims, schema->dims); /* deep clone */
CU_ASSERT_NOT_EQUAL(clone->namehash, schema->namehash); /* deep clone */
hash = schema->namehash;
chash = clone->namehash;
CU_ASSERT_EQUAL(chash->tablelength, hash->tablelength);

8
lib/pc_api.h
View File

@ -88,10 +88,10 @@ typedef struct
size_t size; /* How wide (bytes) is a point with this schema? */
PCDIMENSION **dims; /* Array of dimension pointers */
uint32_t srid; /* Foreign key reference to SPATIAL_REF_SYS */
int32_t x_position; /* What entry is the x coordinate at? */
int32_t y_position; /* What entry is the y coordinate at? */
int32_t z_position; /* What entry is the z coordinate at? */
int32_t m_position; /* What entry is the m coordinate at? */
PCDIMENSION *xdim; /* pointer to the x dimension within dims */
PCDIMENSION *ydim; /* pointer to the y dimension within dims */
PCDIMENSION *zdim; /* pointer to the z dimension within dims */
PCDIMENSION *mdim; /* pointer to the m dimension within dims */
uint32_t compression; /* Compression type applied to the data */
hashtable *namehash; /* Look-up from dimension name to pointer */
} PCSCHEMA;

4
lib/pc_filter.c
View File

@ -166,12 +166,12 @@ pc_patch_dimensional_filter(const PCPATCH_DIMENSIONAL *pdl, const PCBITMAP *map)
stats.sum = pc_value_scale_offset(stats.sum, dim);
/* Save the X/Y stats for use in bounds later */
if ( i == pdl->schema->x_position )
if ( dim == pdl->schema->xdim )
{
fpdl->bounds.xmin = stats.min;
fpdl->bounds.xmax = stats.max;
}
else if ( i == pdl->schema->y_position )
else if ( dim == pdl->schema->ydim )
{
fpdl->bounds.ymin = stats.min;
fpdl->bounds.ymax = stats.max;

14
lib/pc_patch_dimensional.c
View File

@ -185,22 +185,24 @@ pc_patch_dimensional_compute_extent(PCPATCH_DIMENSIONAL *pdl)
assert(pdl);
assert(pdl->schema);
assert(pdl->schema->xdim);
assert(pdl->schema->ydim);
/* Get x extremes */
pcb = &(pdl->bytes[pdl->schema->x_position]);
pcb = &(pdl->bytes[pdl->schema->xdim->position]);
rv = pc_bytes_minmax(pcb, &xmin, &xmax, &xavg);
if ( PC_FAILURE == rv ) return PC_FAILURE;
xmin = pc_value_scale_offset(xmin, pdl->schema->dims[pdl->schema->x_position]);
xmax = pc_value_scale_offset(xmax, pdl->schema->dims[pdl->schema->x_position]);
xmin = pc_value_scale_offset(xmin, pdl->schema->xdim);
xmax = pc_value_scale_offset(xmax, pdl->schema->xdim);
pdl->bounds.xmin = xmin;
pdl->bounds.xmax = xmax;
/* Get y extremes */
pcb = &(pdl->bytes[pdl->schema->y_position]);
pcb = &(pdl->bytes[pdl->schema->ydim->position]);
rv = pc_bytes_minmax(pcb, &ymin, &ymax, &yavg);
if ( PC_FAILURE == rv ) return PC_FAILURE;
ymin = pc_value_scale_offset(ymin, pdl->schema->dims[pdl->schema->y_position]);
ymax = pc_value_scale_offset(ymax, pdl->schema->dims[pdl->schema->y_position]);
ymin = pc_value_scale_offset(ymin, pdl->schema->ydim);
ymax = pc_value_scale_offset(ymax, pdl->schema->ydim);
pdl->bounds.ymin = ymin;
pdl->bounds.ymax = ymax;

16
lib/pc_point.c
View File

@ -143,50 +143,50 @@ pc_point_set_double_by_name(PCPOINT *pt, const char *name, double val)
int
pc_point_get_x(const PCPOINT *pt, double *val)
{
return pc_point_get_double_by_index(pt, pt->schema->x_position, val);
return pc_point_get_double(pt, pt->schema->xdim, val);
}
int
pc_point_get_y(const PCPOINT *pt, double *val)
{
return pc_point_get_double_by_index(pt, pt->schema->y_position, val);
return pc_point_get_double(pt, pt->schema->ydim, val);
}
int
pc_point_get_z(const PCPOINT *pt, double *val)
{
return pc_point_get_double_by_index(pt, pt->schema->z_position, val);
return pc_point_get_double(pt, pt->schema->zdim, val);
}
int
pc_point_get_m(const PCPOINT *pt, double *val)
{
return pc_point_get_double_by_index(pt, pt->schema->m_position, val);
return pc_point_get_double(pt, pt->schema->mdim, val);
}
int
pc_point_set_x(PCPOINT *pt, double val)
{
return pc_point_set_double_by_index(pt, pt->schema->x_position, val);
return pc_point_set_double(pt, pt->schema->xdim, val);
}
int
pc_point_set_y(PCPOINT *pt, double val)
{
return pc_point_set_double_by_index(pt, pt->schema->y_position, val);
return pc_point_set_double(pt, pt->schema->ydim, val);
}
int
pc_point_set_z(PCPOINT *pt, double val)
{
return pc_point_set_double_by_index(pt, pt->schema->z_position, val);
return pc_point_set_double(pt, pt->schema->zdim, val);
}
int
pc_point_set_m(PCPOINT *pt, double val)
{
return pc_point_set_double_by_index(pt, pt->schema->m_position, val);
return pc_point_set_double(pt, pt->schema->mdim, val);
}
char *

25
lib/pc_schema.c
View File

@ -196,10 +196,7 @@ pc_schema_new(uint32_t ndims)
pcs->dims = pcalloc(sizeof(PCDIMENSION*) * ndims);
pcs->namehash = create_string_hashtable();
pcs->ndims = ndims;
pcs->x_position = -1;
pcs->y_position = -1;
pcs->z_position = -1;
pcs->m_position = -1;
/* pcalloc memsets to 0, so xdim,ydim,zdim and mdim are already NULL */
return pcs;
}
@ -237,10 +234,6 @@ pc_schema_clone(const PCSCHEMA *s)
PCSCHEMA *pcs = pc_schema_new(s->ndims);
pcs->pcid = s->pcid;
pcs->srid = s->srid;
pcs->x_position = s->x_position;
pcs->y_position = s->y_position;
pcs->z_position = s->z_position;
pcs->m_position = s->m_position;
pcs->compression = s->compression;
for ( i = 0; i < pcs->ndims; i++ )
{
@ -249,6 +242,10 @@ pc_schema_clone(const PCSCHEMA *s)
pc_schema_set_dimension(pcs, pc_dimension_clone(s->dims[i]));
}
}
pcs->xdim = s->xdim ? pcs->dims[s->xdim->position] : NULL;
pcs->ydim = s->ydim ? pcs->dims[s->ydim->position] : NULL;
pcs->zdim = s->zdim ? pcs->dims[s->zdim->position] : NULL;
pcs->mdim = s->mdim ? pcs->dims[s->mdim->position] : NULL;
pc_schema_calculate_byteoffsets(pcs);
return pcs;
}
@ -341,21 +338,21 @@ void pc_schema_check_xyzm(PCSCHEMA *s)
strcasecmp(dimname, "Longitude") == 0 ||
strcasecmp(dimname, "Lon") == 0 )
{
s->x_position = i;
s->xdim = s->dims[i];
continue;
}
if ( strcasecmp(dimname, "Y") == 0 ||
strcasecmp(dimname, "Latitude") == 0 ||
strcasecmp(dimname, "Lat") == 0 )
{
s->y_position = i;
s->ydim = s->dims[i];
continue;
}
if ( strcasecmp(dimname, "Z") == 0 ||
strcasecmp(dimname, "H") == 0 ||
strcasecmp(dimname, "Height") == 0 )
{
s->z_position = i;
s->zdim = s->dims[i];
continue;
}
if ( strcasecmp(dimname, "M") == 0 ||
@ -363,7 +360,7 @@ void pc_schema_check_xyzm(PCSCHEMA *s)
strcasecmp(dimname, "Time") == 0 ||
strcasecmp(dimname, "GPSTime") == 0 )
{
s->m_position = i;
s->mdim = s->dims[i];
continue;
}
}
@ -584,13 +581,13 @@ pc_schema_is_valid(const PCSCHEMA *s)
{
int i;
if ( s->x_position < 0 )
if ( ! s->xdim )
{
pcwarn("schema does not include an X coordinate");
return PC_FALSE;
}
if ( s->y_position < 0 )
if ( ! s->ydim )
{
pcwarn("schema does not include a Y coordinate");
return PC_FALSE;