void oskar_imager_free(oskar_Imager* h, int* status)
{
int i;
if (!h) return;
oskar_imager_reset_cache(h, status);
oskar_mem_free(h->uu_im, status);
oskar_mem_free(h->vv_im, status);
oskar_mem_free(h->ww_im, status);
oskar_mem_free(h->uu_tmp, status);
oskar_mem_free(h->vv_tmp, status);
oskar_mem_free(h->ww_tmp, status);
oskar_mem_free(h->vis_im, status);
oskar_mem_free(h->weight_im, status);
oskar_mem_free(h->weight_tmp, status);
oskar_mem_free(h->time_im, status);
oskar_timer_free(h->tmr_grid_finalise);
oskar_timer_free(h->tmr_grid_update);
oskar_timer_free(h->tmr_init);
oskar_timer_free(h->tmr_read);
oskar_timer_free(h->tmr_write);
oskar_mutex_free(h->mutex);
oskar_imager_free_device_data(h, status);
for (i = 0; i < h->num_files; ++i)
free(h->input_files[i]);
free(h->input_files);
free(h->input_root);
free(h->output_root);
free(h->ms_column);
free(h->gpu_ids);
free(h->d);
free(h);
}
void oskar_imager_set_algorithm(oskar_Imager* h, const char* type,
int* status)
{
if (*status) return;
h->image_padding = 1.0;
if (!strncmp(type, "FFT", 3) || !strncmp(type, "fft", 3))
{
h->algorithm = OSKAR_ALGORITHM_FFT;
h->kernel_type = 'S';
h->support = 3;
h->oversample = 100;
}
else if (!strncmp(type, "W", 1) || !strncmp(type, "w", 1))
{
h->algorithm = OSKAR_ALGORITHM_WPROJ;
h->oversample = 4;
h->image_padding = 1.2;
}
else if (!strncmp(type, "DFT 2", 5) || !strncmp(type, "dft 2", 5))
h->algorithm = OSKAR_ALGORITHM_DFT_2D;
else if (!strncmp(type, "DFT 3", 5) || !strncmp(type, "dft 3", 5))
h->algorithm = OSKAR_ALGORITHM_DFT_3D;
else *status = OSKAR_ERR_INVALID_ARGUMENT;
/* Recalculate grid plane size. */
h->grid_size = 0;
oskar_imager_reset_cache(h, status);
(void) oskar_imager_plane_size(h);
}
void oskar_imager_finalise(oskar_Imager* h,
int num_output_images, oskar_Mem** output_images,
int num_output_grids, oskar_Mem** output_grids, int* status)
{
int t, c, p, i;
if (*status || !h->planes) return;
/* Adjust normalisation if required. */
if (h->scale_norm_with_num_input_files)
{
for (i = 0; i < h->num_planes; ++i)
h->plane_norm[i] /= h->num_files;
}
/* Copy grids to output grid planes if given. */
for (i = 0; (i < h->num_planes) && (i < num_output_grids); ++i)
{
oskar_mem_copy(output_grids[i], h->planes[i], status);
oskar_mem_scale_real(output_grids[i], 1.0 / h->plane_norm[i], status);
}
/* Check if images are required. */
if (h->fits_file[0] || output_images)
{
/* Finalise all the planes. */
for (i = 0; i < h->num_planes; ++i)
{
oskar_imager_finalise_plane(h,
h->planes[i], h->plane_norm[i], status);
oskar_imager_trim_image(h->planes[i],
h->grid_size, h->image_size, status);
}
/* Copy images to output image planes if given. */
for (i = 0; (i < h->num_planes) && (i < num_output_images); ++i)
{
memcpy(oskar_mem_void(output_images[i]),
oskar_mem_void_const(h->planes[i]), h->image_size *
h->image_size * oskar_mem_element_size(h->imager_prec));
}
/* Write to files if required. */
for (t = 0, i = 0; t < h->im_num_times; ++t)
for (c = 0; c < h->im_num_channels; ++c)
for (p = 0; p < h->im_num_pols; ++p, ++i)
write_plane(h, h->planes[i], t, c, p, status);
}
/* Reset imager memory. */
oskar_imager_reset_cache(h, status);
}
void oskar_imager_set_size(oskar_Imager* h, int size, int* status)
{
if (size < 2 || size % 2 != 0)
{
*status = OSKAR_ERR_INVALID_ARGUMENT;
return;
}
h->image_size = size;
h->grid_size = 0;
oskar_imager_reset_cache(h, status);
(void) oskar_imager_plane_size(h);
if (h->set_fov)
h->cellsize_rad = oskar_convert_fov_to_cellsize(
h->fov_deg * (M_PI / 180.0), h->image_size);
else if (h->set_cellsize)
h->fov_deg = oskar_convert_cellsize_to_fov(
h->cellsize_rad, h->image_size) * (180.0 / M_PI);
}
