zoom_filter_t * make_compound_sample_zoom(compounds_sample_t *s){
zoom_filter_t *zf = new_zoom_filter(n_elements_from_sampsz(s->sample_size));
if(zf == NULL){
char * m = "failed new zdf";
transmit_all(STDOUT, m, strlen(m));
return NULL;
}
for(int i =0; i < s->sample_size; ++i){
int sample_idx = get_chem_ref_at_idx(s, i);
if(sample_idx > N_FORMULAS-1 ){
// todo free zf
char * m = "failed new zdf2";
transmit_all(STDOUT, m, strlen(m));
zoom_free(zf);
return NULL;
}
char * cn = chem_formulas[sample_idx].compound_name;
hash_pair_t *hp = hash_pair_buf(cn, strlen(cn) );
zoom_add(hp, zf);
// todo check number transmitted
}
return zf;
}
char * zoom_buf(compounds_sample_t *s){
zoom_filter_t *zf = make_compound_sample_zoom(s);
if(zf == NULL)
return NULL;
char * tx_buf = encode((char *) zf->data, zf->data_len);
zoom_free(zf);
return tx_buf;
}
ZoomInfo *zoom_init(int old_w, int old_h, int new_w, int new_h, int Bpp,
int old_stride, int new_stride, TCVZoomFilter filter)
{
ZoomInfo *zi;
struct clist *x_contrib = NULL, *y_contrib = NULL;
/* Sanity check */
if (old_w <= 0 || old_h <= 0 || new_w <= 0 || new_h <= 0 || Bpp <= 0
|| old_stride <= 0 || new_stride <= 0)
return NULL;
/* Allocate structure */
zi = tc_malloc(sizeof(*zi));
if (!zi)
return NULL;
/* Set up scalar members, and check filter value */
zi->old_w = old_w;
zi->old_h = old_h;
zi->new_w = new_w;
zi->new_h = new_h;
zi->Bpp = Bpp;
zi->old_stride = old_stride;
zi->new_stride = new_stride;
switch (filter) {
case TCV_ZOOM_BOX:
zi->filter = box_filter;
zi->fwidth = box_support;
break;
case TCV_ZOOM_TRIANGLE:
zi->filter = triangle_filter;
zi->fwidth = triangle_support;
break;
case TCV_ZOOM_HERMITE:
zi->filter = hermite_filter;
zi->fwidth = hermite_support;
break;
case TCV_ZOOM_BELL:
zi->filter = bell_filter;
zi->fwidth = bell_support;
break;
case TCV_ZOOM_B_SPLINE:
zi->filter = B_spline_filter;
zi->fwidth = B_spline_support;
break;
case TCV_ZOOM_MITCHELL:
zi->filter = mitchell_filter;
zi->fwidth = mitchell_support;
break;
case TCV_ZOOM_LANCZOS3:
zi->filter = lanczos3_filter;
zi->fwidth = lanczos3_support;
break;
case TCV_ZOOM_CUBIC_KEYS4:
zi->filter = cubic_keys4_filter;
zi->fwidth = cubic_keys4_support;
break;
case TCV_ZOOM_SINC8:
zi->filter = sinc8_filter;
zi->fwidth = sinc8_support;
break;
default:
free(zi);
return NULL;
}
/* Generate contributor lists and allocate temporary image buffer */
zi->x_contrib = NULL;
zi->y_contrib = NULL;
zi->tmpimage = tc_malloc(new_w * old_h * Bpp);
if (!zi->tmpimage)
goto error_out;
if (old_w != new_w) {
x_contrib = gen_contrib(old_w, new_w, Bpp, zi->filter, zi->fwidth);
if (!x_contrib)
goto error_out;
}
if (old_h != new_h) {
/* Calculate the correct stride--if the width isn't changing,
* this will just be old_stride */
int stride = (old_w==new_w) ? old_stride : Bpp*new_w;
y_contrib = gen_contrib(old_h, new_h, stride, zi->filter,
zi->fwidth);
if (!y_contrib)
goto error_out;
}
/* Convert contributor lists into flat arrays and fixed-point values.
* The flat array consists of a contributor count plus two values per
* contributor (index and fixed-point weight) for each output pixel.
* Note that for the horizontal direction, we make `Bpp' copies of the
* contributors, adjusting the offset for each byte of the pixel. */
if (x_contrib) {
int count = 0, i;
int32_t *ptr;
for (i = 0; i < new_w; i++)
count += 1 + 2 * x_contrib[i].n;
zi->x_contrib = tc_malloc(sizeof(int32_t) * count * Bpp);
if (!zi->x_contrib)
goto error_out;
for (ptr = zi->x_contrib, i = 0; i < new_w * Bpp; i++) {
int j;
*ptr++ = x_contrib[i/Bpp].n;
for (j = 0; j < x_contrib[i/Bpp].n; j++) {
*ptr++ = x_contrib[i/Bpp].list[j].pixel + i%Bpp;
*ptr++ = DOUBLE_TO_FIXED(x_contrib[i/Bpp].list[j].weight);
}
}
/* Free original contributor list */
for (i = 0; i < new_w; i++)
free(x_contrib[i].list);
free(x_contrib);
x_contrib = NULL;
}
if (y_contrib) {
int count = 0, i;
int32_t *ptr;
for (i = 0; i < new_h; i++)
count += 1 + 2 * y_contrib[i].n;
zi->y_contrib = tc_malloc(sizeof(int32_t) * count);
if (!zi->y_contrib)
goto error_out;
for (ptr = zi->y_contrib, i = 0; i < new_h; i++) {
int j;
*ptr++ = y_contrib[i].n;
for (j = 0; j < y_contrib[i].n; j++) {
*ptr++ = y_contrib[i].list[j].pixel;
*ptr++ = DOUBLE_TO_FIXED(y_contrib[i].list[j].weight);
}
}
for (i = 0; i < new_h; i++)
free(y_contrib[i].list);
free(y_contrib);
y_contrib = NULL;
}
/* Done */
return zi;
error_out:
{
if (x_contrib) {
int i;
for (i = 0; i < new_w; i++)
free(x_contrib[i].list);
free(x_contrib);
}
if (y_contrib) {
int i;
for (i = 0; i < new_w; i++)
free(x_contrib[i].list);
free(x_contrib);
}
zoom_free(zi);
return NULL;
}
}
