functions.R

calc_angle_of_view <- function(d_sensor, f) {
  angle_of_view <- 2 * atan(d_sensor / (2 * f))
  return(angle_of_view)
}

calc_ground_sampling_distance <- function(flight_height, d_sensor, n_pix, f) {
  return((d_sensor/n_pix) * flight_height / f)
}

calc_ground_sampling_distance_mm <- function(flight_height, d_sensor, n_pix, f) {
  return(1000 *calc_ground_sampling_distance(flight_height, d_sensor, n_pix, f))
}

calc_ground_field_of_view <- function(flight_height, d_sensor, f) {
  return((d_sensor) * flight_height / f)
}

calc_flight_height <- function(ground_sampling_distance, d_sensor, n_pix, f) {
  return(ground_sampling_distance / (d_sensor/n_pix) *f)
}

calc_flight_height_mm <- function(ground_sampling_distance_mm, d_sensor, n_pix, f) {
  return((ground_sampling_distance_mm/1000) / (d_sensor/n_pix) *f)
}

calc_hyperfocal_distance <- function(f, aperture, circle_of_confusion) {
  return((f^2)/(aperture*circle_of_confusion) + f)
}

calc_focus_distance <- function(f, aperture, circle_of_confusion, flight_height) {
  hyperfocal_distance <- calc_hyperfocal_distance(f, aperture, circle_of_confusion)
  
  focus_dist <- (hyperfocal_distance * sqrt(flight_height))/(sqrt(hyperfocal_distance + flight_height))
  
  focus_dist <- (-hyperfocal_distance^2 + sqrt(hyperfocal_distance^4 + 4 * hyperfocal_distance^2 * flight_height^2))/(2 * flight_height)
  
  focus_dist <- ifelse(focus_dist > hyperfocal_distance, hyperfocal_distance, focus_dist)
  return(focus_dist)
}

calc_depth_of_field_near <- function(f, aperture, circle_of_confusion, focus_distance) {
  hyperfocal_distance <- calc_hyperfocal_distance(f, aperture, circle_of_confusion)
  return(focus_distance / ( (focus_distance - f) / (hyperfocal_distance - f) + 1))
}

calc_depth_of_field_far <- function(f, aperture, circle_of_confusion, focus_distance) {
  hyperfocal_distance <- calc_hyperfocal_distance(f, aperture, circle_of_confusion)
  return(ifelse(focus_distance <= hyperfocal_distance, (focus_distance / ( (f - focus_distance) / (hyperfocal_distance - f) + 1)), Inf))
}

calc_shutter_speed <- function(exposure_value, aperture, iso=100) {

  return(as.numeric(iso)/(25.0 * 2.0^(2.0+as.numeric(exposure_value))/(as.numeric(aperture)^2.0)))
}

calc_iso <- function(exposure_value, aperture, shutter_speed) {
  return((25.0 * as.numeric(aperture)^2.0 * 2.0^(2.0-as.numeric(exposure_value)))/((1/as.numeric(shutter_speed))))

}

calc_spacing_exposure_station <- function(end_lap, ground_field_of_view_x) {
  return(ground_field_of_view_x - ((end_lap/100) * ground_field_of_view_x))
}

calc_spacing_flight_lines <- function(side_lap, ground_field_of_view_y) {
  return(ground_field_of_view_y - (side_lap/100) * ground_field_of_view_y)
}

calc_end_lap <- function(spacing_exposure_station, ground_field_of_view_x) {
  return(100 - (spacing_exposure_station/ ground_field_of_view_x)*100)
}

calc_side_lap <- function(spacing_flight_lines, ground_field_of_view_y) {
  return(100 - (spacing_flight_lines/ ground_field_of_view_y)*100)
}

calc_flight_speed <- function(ground_sampling_distance, motion_blur, shutter_speed) {
  return(((ground_sampling_distance)*motion_blur) / (1/shutter_speed))
}

calc_motion_blur <- function(ground_sampling_distance, flight_speed, shutter_speed) {
  return((flight_speed * (1/shutter_speed))/ground_sampling_distance)
}

calc_image_recording_speed <- function(flight_speed, spacing_exposure_station) {
  return(flight_speed / spacing_exposure_station)
}

calc_flight_distance <- function(distance_area_x, ground_field_of_view_x, distance_area_y, ground_field_of_view_y, spacing_flight_lines) {
  distance <- 1 * (distance_area_x + ceiling(ground_field_of_view_x / (2 * spacing_flight_lines))) * 2 * spacing_flight_lines + (distance_area_x/spacing_flight_lines) * (distance_area_y + ground_field_of_view_y)
  return(distance)
}

calc_flight_duration <- function(distance_area_x, ground_field_of_view_x, distance_area_y, ground_field_of_view_y, spacing_flight_lines, flight_speed) {
  distance <- 1 * (distance_area_x + ceiling(ground_field_of_view_x / (2 * spacing_flight_lines))) * 2 * spacing_flight_lines + (distance_area_x/spacing_flight_lines) * (distance_area_y + ground_field_of_view_y)
  duration <- (distance / flight_speed) / 60
  return(duration)
}

calc_pixel_freq <- function(plot_size, spacing, no_of_lanes, position_precision_sd, n_pix, ground_sampling_distance, use_uniform=FALSE) {
  
  # Initialize sensor axis
  pixels <- 1:n_pix
  # Positions of plots, pixel position as index, TRUE as value if plot present, else FALSE
  plot_positions <- ifelse(seq(1, n_pix + no_of_lanes*spacing/ground_sampling_distance) %% round(plot_size/ground_sampling_distance) + round(plot_size/(ground_sampling_distance*2))  == round(plot_size/(ground_sampling_distance)), TRUE, FALSE)
  
  # Get camera views on plots
  sensor_views <- rollapply(data=plot_positions, width=n_pix, by=round(spacing/ground_sampling_distance), FUN = function(x) x)
  
  # Calculate frequency of plots at specific sensor position
  sensor_position_freq <- apply(sensor_views, MARGIN=c(2), sum)
  # Normalize
  sensor_position_freq <- sensor_position_freq / sum(sensor_position_freq)
  
  # Normal distribution for each sensor pixel
  if(!use_uniform) {
    pixel_distribution <- mapply(pixels, FUN=function(z) {dnorm(x=pixels, sd=position_precision_sd/ground_sampling_distance, mean=z)})
  } else {
    pixel_distribution <- mapply(pixels, FUN=function(z) {dunif(x=pixels, min=z-(position_precision_sd/ground_sampling_distance), max=z+(position_precision_sd/ground_sampling_distance))})
  }
  # Sweep over columns and multiply with occurance frequency of sensor at this position
  pixel_distribution_sens <- sweep(pixel_distribution, MARGIN=2, sensor_position_freq, '*')
  # Sum up result
  pixel_frequency <- rowSums(pixel_distribution_sens)
  # Normalize
  pixel_frequency <- pixel_frequency / sum(pixel_frequency)

  pixel_frequency_data <- data.frame(x=1:n_pix, freq=pixel_frequency)
  
  return(pixel_frequency_data)
}

calc_pixel_freq_xy <- function(plot_size_x, plot_size_y, spacing_x, spacing_y, no_of_lanes_x, no_of_lanes_y, n_pix_x, n_pix_y, position_precision_sd, ground_sampling_distance) {
  
  pixel_frequency_data_x <- calc_pixel_freq(plot_size_x, spacing_x, no_of_lanes_x, position_precision_sd, n_pix_x, ground_sampling_distance)
  pixel_frequency_data_y <- calc_pixel_freq(plot_size_y, spacing_y, no_of_lanes_y, position_precision_sd, n_pix_y, ground_sampling_distance, use_uniform = TRUE)
  
  pixel_frequency_data_xy <- unlist(pixel_frequency_data_y[,'freq']) %o% unlist(pixel_frequency_data_x[,'freq'])
  pixel_frequency_data_xy <- (pixel_frequency_data_xy / max(pixel_frequency_data_xy))
  return(list(pixel_frequency_data_xy, pixel_frequency_data_x, pixel_frequency_data_y))
}


long2UTM <- function(long) {
  (floor((long + 180)/6) %% 60) + 1
}