GeoRasterTableFunctions.hpp File Reference

#include <cmath>
#include <vector>
#include <tbb/parallel_for.h>
#include <tbb/task_arena.h>
#include "QueryEngine/heavydbTypes.h"
#include "Shared/StringTransform.h"
#include "Shared/TableFunctionsCommon.hpp"
#include "Shared/math_consts.h"

Include dependency graph for GeoRasterTableFunctions.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ComputeAgg< AggType >
struct	ComputeAgg< RasterAggType::COUNT >
struct	ComputeAgg< RasterAggType::MAX >
struct	ComputeAgg< RasterAggType::MIN >
struct	ComputeAgg< RasterAggType::SUM >
struct	ComputeAgg< RasterAggType::BOX_AVG >
struct	GeoRaster< T, Z >

Enumerations
enum	RasterAggType {   RasterAggType::COUNT, RasterAggType::MIN, RasterAggType::MAX, RasterAggType::SUM,   RasterAggType::AVG, RasterAggType::GAUSS_AVG, RasterAggType::BOX_AVG, RasterAggType::INVALID }

Functions
RasterAggType	get_raster_agg_type (const std::string &agg_type_str, const bool is_fill_agg)
std::vector< double >	generate_1d_gaussian_kernel (const int64_t fill_radius, double sigma)
template<typename T , typename Z >
TEMPLATE_NOINLINE int32_t	geo_rasterize_impl (TableFunctionManager &mgr, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, const RasterAggType raster_agg_type, const RasterAggType raster_fill_agg_type, const T bin_dim_meters, const bool geographic_coords, const int64_t neighborhood_fill_radius, const bool fill_only_nulls, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z)
template<typename T , typename Z >
TEMPLATE_NOINLINE int32_t	tf_geo_rasterize__cpu_template (TableFunctionManager &mgr, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, const TextEncodingNone &agg_type_str, const T bin_dim_meters, const bool geographic_coords, const int64_t neighborhood_fill_radius, const bool fill_only_nulls, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z)
template<typename T , typename Z >
TEMPLATE_NOINLINE int32_t	tf_geo_rasterize__cpu_template (TableFunctionManager &mgr, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, const TextEncodingNone &agg_type_str, const TextEncodingNone &fill_agg_type_str, const T bin_dim_meters, const bool geographic_coords, const int64_t neighborhood_fill_radius, const bool fill_only_nulls, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z)
template<typename T , typename Z >
TEMPLATE_NOINLINE int32_t	tf_geo_rasterize__cpu_template (TableFunctionManager &mgr, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, const TextEncodingNone &agg_type_str, const TextEncodingNone &fill_agg_type_str, const T bin_dim_meters, const bool geographic_coords, const int64_t neighborhood_fill_radius, const bool fill_only_nulls, const T x_min, const T x_max, const T y_min, const T y_max, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z)
template<typename T , typename Z >
TEMPLATE_NOINLINE int32_t	tf_geo_multi_rasterize__cpu_template (TableFunctionManager &mgr, const Column< T > &input_x, const Column< T > &input_y, const ColumnList< Z > &input_z_cols, const TextEncodingNone &agg_types_str, const TextEncodingNone &fill_agg_types_str, const T bin_dim_meters, const bool geographic_coords, const int64_t neighborhood_fill_radius, const bool fill_only_nulls, Column< T > &output_x, Column< T > &output_y, Column< Array< Z >> &output_z)
template<typename T , typename Z >
TEMPLATE_NOINLINE int32_t	tf_geo_rasterize_slope__cpu_template (TableFunctionManager &mgr, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, const TextEncodingNone &agg_type_str, const T bin_dim_meters, const bool geographic_coords, const int64_t neighborhood_fill_radius, const bool fill_only_nulls, const bool compute_slope_in_degrees, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z, Column< Z > &output_slope, Column< Z > &output_aspect)

Variables
const size_t	max_inputs_per_thread = 1000000L
const size_t	max_temp_output_entries = 200000000L

Enumeration Type Documentation

enum RasterAggType

strong

Enumerator
COUNT
MIN
MAX
SUM
AVG
GAUSS_AVG
BOX_AVG
INVALID

Definition at line 36 of file GeoRasterTableFunctions.hpp.

{ COUNT, MIN, MAX, SUM, AVG, GAUSS_AVG, BOX_AVG, INVALID };

Function Documentation

std::vector<double> generate_1d_gaussian_kernel	(	const int64_t	fill_radius,
		double	sigma
	)

Definition at line 46 of file GeoRasterTableFunctions.cpp.

References M_PI.

Referenced by GeoRaster< T, Z >::fill_bins_from_gaussian_neighborhood().

                                                                                       {
  const int64_t kernel_size = fill_radius * 2 + 1;
  std::vector<double> gaussian_kernel(kernel_size);
  const double expr = 1.0 / (sigma * sqrt(2.0 * M_PI));
  for (int64_t kernel_idx = -fill_radius; kernel_idx <= fill_radius; ++kernel_idx) {
    gaussian_kernel[kernel_idx + fill_radius] =
        expr * exp((kernel_idx * kernel_idx) / (-2.0 * (sigma * sigma)));
  }
  return gaussian_kernel;
}

Here is the caller graph for this function:

template<typename T , typename Z >

TEMPLATE_NOINLINE int32_t geo_rasterize_impl	(	TableFunctionManager &	mgr,
		const Column< T > &	input_x,
		const Column< T > &	input_y,
		const Column< Z > &	input_z,
		const RasterAggType	raster_agg_type,
		const RasterAggType	raster_fill_agg_type,
		const T	bin_dim_meters,
		const bool	geographic_coords,
		const int64_t	neighborhood_fill_radius,
		const bool	fill_only_nulls,
		Column< T > &	output_x,
		Column< T > &	output_y,
		Column< Z > &	output_z
	)

Definition at line 1209 of file GeoRasterTableFunctions.hpp.

References GeoRaster< T, Z >::fill_bins_from_neighbors(), GeoRaster< T, Z >::outputDenseColumns(), and GeoRaster< T, Z >::setMetadata().

Referenced by tf_geo_rasterize__cpu_template().

                                                                  {
  GeoRaster<T, Z> geo_raster(input_x,
                             input_y,
                             input_z,
                             raster_agg_type,
                             bin_dim_meters,
                             geographic_coords,
                             true);

  geo_raster.setMetadata(mgr);

  if (neighborhood_fill_radius > 0) {
    geo_raster.fill_bins_from_neighbors(
        neighborhood_fill_radius, fill_only_nulls, raster_fill_agg_type);
  }

  return geo_raster.outputDenseColumns(mgr, output_x, output_y, output_z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RasterAggType get_raster_agg_type	(	const std::string &	agg_type_str,
		const bool	is_fill_agg
	)

Definition at line 21 of file GeoRasterTableFunctions.cpp.

References AVG, BOX_AVG, COUNT, GAUSS_AVG, INVALID, MAX, MIN, SUM, and to_upper().

Referenced by tf_geo_multi_rasterize__cpu_template(), tf_geo_rasterize__cpu_template(), tf_geo_rasterize_slope__cpu_template(), and GDALTableFunctions::tf_raster_contour_rasterize_impl().

                                                          {
  const auto upper_agg_type_str = to_upper(agg_type_str);
  const static std::map<std::string, RasterAggType> agg_type_map = {
      {"COUNT", RasterAggType::COUNT},
      {"MIN", RasterAggType::MIN},
      {"MAX", RasterAggType::MAX},
      {"SUM", RasterAggType::SUM},
      {"AVG", RasterAggType::AVG},
      {"GAUSS_AVG", RasterAggType::GAUSS_AVG},
      {"BOX_AVG", RasterAggType::BOX_AVG}};
  const auto itr = agg_type_map.find(upper_agg_type_str);
  if (itr == agg_type_map.end()) {
    return RasterAggType::INVALID;
  }
  if (is_fill_agg && itr->second == RasterAggType::AVG) {
    return RasterAggType::GAUSS_AVG;
  } else if (!is_fill_agg && (itr->second == RasterAggType::BOX_AVG ||
                              itr->second == RasterAggType::GAUSS_AVG)) {
    // GAUSS_AVG and BOX_AVG are fill-only aggregates
    return RasterAggType::INVALID;
  }
  return itr->second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T , typename Z >

TEMPLATE_NOINLINE int32_t tf_geo_multi_rasterize__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input_x,
		const Column< T > &	input_y,
		const ColumnList< Z > &	input_z_cols,
		const TextEncodingNone &	agg_types_str,
		const TextEncodingNone &	fill_agg_types_str,
		const T	bin_dim_meters,
		const bool	geographic_coords,
		const int64_t	neighborhood_fill_radius,
		const bool	fill_only_nulls,
		Column< T > &	output_x,
		Column< T > &	output_y,
		Column< Array< Z >> &	output_z
	)

Definition at line 1429 of file GeoRasterTableFunctions.hpp.

References GeoRaster< T, Z >::fill_bins_from_neighbors(), get_raster_agg_type(), TextEncodingNone::getString(), INVALID, ColumnList< T >::numCols(), GeoRaster< T, Z >::outputDenseColumns(), GeoRaster< T, Z >::setMetadata(), split(), and GeoRaster< T, Z >::z_cols_.

                                                                 {
  const int64_t num_z_cols = input_z_cols.numCols();
  const auto agg_types_strs = split(agg_types_str.getString(), "|");
  const auto fill_agg_types_strs = split(fill_agg_types_str.getString(), "|");
  if (num_z_cols != static_cast<int64_t>(agg_types_strs.size()) ||
      num_z_cols != static_cast<int64_t>(fill_agg_types_strs.size())) {
    const std::string error_msg =
        "Mismatch between number of cols and number of agg or fill agg types.";
    return mgr.ERROR_MESSAGE(error_msg);
  }

  auto get_agg_types = [](const std::vector<std::string>& agg_types_strs,
                          const bool is_fill_agg) {
    std::vector<RasterAggType> agg_types;
    for (const auto& agg_type_str : agg_types_strs) {
      agg_types.emplace_back(get_raster_agg_type(agg_type_str, is_fill_agg));
      if (agg_types.back() == RasterAggType::INVALID) {
        throw std::runtime_error("Invalid agg type");
      }
    }
    return agg_types;
  };

  std::vector<RasterAggType> raster_agg_types;
  std::vector<RasterAggType> raster_fill_agg_types;
  try {
    raster_agg_types = get_agg_types(agg_types_strs, false);
    raster_fill_agg_types = get_agg_types(fill_agg_types_strs, true);
  } catch (std::exception& e) {
    return mgr.ERROR_MESSAGE(e.what());
  }

  GeoRaster<T, Z> geo_raster(input_x,
                             input_y,
                             input_z_cols,
                             raster_agg_types,
                             bin_dim_meters,
                             geographic_coords,
                             true);
  geo_raster.setMetadata(mgr);

  if (neighborhood_fill_radius > 0) {
    for (int64_t z_col_idx = 0; z_col_idx < num_z_cols; ++z_col_idx) {
      geo_raster.fill_bins_from_neighbors(neighborhood_fill_radius,
                                          fill_only_nulls,
                                          raster_fill_agg_types[z_col_idx],
                                          geo_raster.z_cols_[z_col_idx]);
    }
  }
  return geo_raster.outputDenseColumns(mgr, output_x, output_y, output_z);
}

Here is the call graph for this function:

template<typename T , typename Z >

TEMPLATE_NOINLINE int32_t tf_geo_rasterize__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input_x,
		const Column< T > &	input_y,
		const Column< Z > &	input_z,
		const TextEncodingNone &	agg_type_str,
		const T	bin_dim_meters,
		const bool	geographic_coords,
		const int64_t	neighborhood_fill_radius,
		const bool	fill_only_nulls,
		Column< T > &	output_x,
		Column< T > &	output_y,
		Column< Z > &	output_z
	)

Definition at line 1255 of file GeoRasterTableFunctions.hpp.

References GAUSS_AVG, geo_rasterize_impl(), get_raster_agg_type(), TextEncodingNone::getString(), and INVALID.

                                                    {
  const auto raster_agg_type = get_raster_agg_type(agg_type_str, false);
  if (raster_agg_type == RasterAggType::INVALID) {
    const std::string error_msg =
        "Invalid Raster Aggregate Type: " + agg_type_str.getString();
    return mgr.ERROR_MESSAGE(error_msg);
  }
  return geo_rasterize_impl(mgr,
                            input_x,
                            input_y,
                            input_z,
                            raster_agg_type,
                            RasterAggType::GAUSS_AVG,
                            bin_dim_meters,
                            geographic_coords,
                            neighborhood_fill_radius,
                            fill_only_nulls,
                            output_x,
                            output_y,
                            output_z);
}

Here is the call graph for this function:

template<typename T , typename Z >

TEMPLATE_NOINLINE int32_t tf_geo_rasterize__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input_x,
		const Column< T > &	input_y,
		const Column< Z > &	input_z,
		const TextEncodingNone &	agg_type_str,
		const TextEncodingNone &	fill_agg_type_str,
		const T	bin_dim_meters,
		const bool	geographic_coords,
		const int64_t	neighborhood_fill_radius,
		const bool	fill_only_nulls,
		Column< T > &	output_x,
		Column< T > &	output_y,
		Column< Z > &	output_z
	)

Definition at line 1304 of file GeoRasterTableFunctions.hpp.

References geo_rasterize_impl(), get_raster_agg_type(), TextEncodingNone::getString(), and INVALID.

                                                    {
  const auto raster_agg_type = get_raster_agg_type(agg_type_str, false);
  if (raster_agg_type == RasterAggType::INVALID) {
    const std::string error_msg =
        "Invalid Raster Aggregate Type: " + agg_type_str.getString();
    return mgr.ERROR_MESSAGE(error_msg);
  }
  const auto raster_fill_agg_type = get_raster_agg_type(fill_agg_type_str, true);
  if (raster_fill_agg_type == RasterAggType::INVALID) {
    const std::string error_msg =
        "Invalid Raster Fill Aggregate Type: " + fill_agg_type_str.getString();
    return mgr.ERROR_MESSAGE(error_msg);
  }
  return geo_rasterize_impl(mgr,
                            input_x,
                            input_y,
                            input_z,
                            raster_agg_type,
                            raster_fill_agg_type,
                            bin_dim_meters,
                            geographic_coords,
                            neighborhood_fill_radius,
                            fill_only_nulls,
                            output_x,
                            output_y,
                            output_z);
}

Here is the call graph for this function:

template<typename T , typename Z >

TEMPLATE_NOINLINE int32_t tf_geo_rasterize__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input_x,
		const Column< T > &	input_y,
		const Column< Z > &	input_z,
		const TextEncodingNone &	agg_type_str,
		const TextEncodingNone &	fill_agg_type_str,
		const T	bin_dim_meters,
		const bool	geographic_coords,
		const int64_t	neighborhood_fill_radius,
		const bool	fill_only_nulls,
		const T	x_min,
		const T	x_max,
		const T	y_min,
		const T	y_max,
		Column< T > &	output_x,
		Column< T > &	output_y,
		Column< Z > &	output_z
	)

Definition at line 1361 of file GeoRasterTableFunctions.hpp.

References GeoRaster< T, Z >::fill_bins_from_neighbors(), get_raster_agg_type(), TextEncodingNone::getString(), INVALID, GeoRaster< T, Z >::outputDenseColumns(), and GeoRaster< T, Z >::setMetadata().

                                                    {
  const auto raster_agg_type = get_raster_agg_type(agg_type_str, false);
  if (raster_agg_type == RasterAggType::INVALID) {
    const std::string error_msg =
        "Invalid Raster Aggregate Type: " + agg_type_str.getString();
    return mgr.ERROR_MESSAGE(error_msg);
  }
  const auto raster_fill_agg_type = get_raster_agg_type(fill_agg_type_str, true);
  if (raster_fill_agg_type == RasterAggType::INVALID) {
    const std::string error_msg =
        "Invalid Raster Fill Aggregate Type: " + fill_agg_type_str.getString();
    return mgr.ERROR_MESSAGE(error_msg);
  }

  GeoRaster<T, Z> geo_raster(input_x,
                             input_y,
                             input_z,
                             raster_agg_type,
                             bin_dim_meters,
                             geographic_coords,
                             true,
                             x_min,
                             x_max,
                             y_min,
                             y_max);

  geo_raster.setMetadata(mgr);

  if (neighborhood_fill_radius > 0) {
    geo_raster.fill_bins_from_neighbors(
        neighborhood_fill_radius, fill_only_nulls, raster_fill_agg_type);
  }

  return geo_raster.outputDenseColumns(mgr, output_x, output_y, output_z);
}

Here is the call graph for this function:

template<typename T , typename Z >

TEMPLATE_NOINLINE int32_t tf_geo_rasterize_slope__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input_x,
		const Column< T > &	input_y,
		const Column< Z > &	input_z,
		const TextEncodingNone &	agg_type_str,
		const T	bin_dim_meters,
		const bool	geographic_coords,
		const int64_t	neighborhood_fill_radius,
		const bool	fill_only_nulls,
		const bool	compute_slope_in_degrees,
		Column< T > &	output_x,
		Column< T > &	output_y,
		Column< Z > &	output_z,
		Column< Z > &	output_slope,
		Column< Z > &	output_aspect
	)

Definition at line 1509 of file GeoRasterTableFunctions.hpp.

References GeoRaster< T, Z >::calculate_slope_and_aspect(), GeoRaster< T, Z >::fill_bins_from_neighbors(), GAUSS_AVG, get_raster_agg_type(), TextEncodingNone::getString(), INVALID, GeoRaster< T, Z >::outputDenseColumns(), and GeoRaster< T, Z >::setMetadata().

                                                               {
  const auto raster_agg_type = get_raster_agg_type(agg_type_str, false);
  if (raster_agg_type == RasterAggType::INVALID) {
    const std::string error_msg =
        "Invalid Raster Aggregate Type: " + agg_type_str.getString();
    return mgr.ERROR_MESSAGE(error_msg);
  }

  GeoRaster<T, Z> geo_raster(input_x,
                             input_y,
                             input_z,
                             raster_agg_type,
                             bin_dim_meters,
                             geographic_coords,
                             true);
  geo_raster.setMetadata(mgr);

  if (neighborhood_fill_radius > 0) {
    geo_raster.fill_bins_from_neighbors(
        neighborhood_fill_radius, fill_only_nulls, RasterAggType::GAUSS_AVG);
  }

  const size_t output_rows =
      geo_raster.outputDenseColumns(mgr, output_x, output_y, output_z);
  geo_raster.calculate_slope_and_aspect(
      output_slope, output_aspect, compute_slope_in_degrees);
  return output_rows;
}

Here is the call graph for this function:

Variable Documentation

const size_t max_inputs_per_thread = 1000000L

Definition at line 32 of file GeoRasterTableFunctions.hpp.

Referenced by GeoRaster< T, Z >::compute(), compute_table_function_col_chunk_stats(), GeoRaster< T, Z >::GeoRaster(), get_column_mean(), get_column_metadata(), get_column_min_max(), get_column_stats(), get_column_std_dev(), and r2_score_impl().

const size_t max_temp_output_entries = 200000000L

Definition at line 33 of file GeoRasterTableFunctions.hpp.

Referenced by GeoRaster< T, Z >::computeParallelImpl().