AtmosphericComputationParameters.java
/* Copyright 2013-2019 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* CS licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.orekit.rugged.refraction;
import org.orekit.rugged.errors.RuggedException;
import org.orekit.rugged.errors.RuggedMessages;
import org.orekit.rugged.linesensor.LineSensor;
import org.orekit.rugged.utils.GridCreation;
/**
* Atmospheric refraction computation parameters.
* Defines for inverse location a set of parameters in order to be able to perform the computation.
* @author Guylaine Prat
* @since 2.1
*/
public class AtmosphericComputationParameters {
/** Margin for definition of the interpolation grid.
* To be inside the min line and max line range to avoid problem with inverse location grid computation. */
private static final int MARGIN_LINE = 10;
/** Default value for pixel step. */
private static final int DEFAULT_STEP_PIXEL = 100;
/** Default value for line step. */
private static final int DEFAULT_STEP_LINE = 100;
/** Actual values for pixel step in case default are overwritten. */
private int pixelStep;
/** Actual values for line step in case default are overwritten. */
private int lineStep;
// Definition of grids for sensor (u = along pixel; v = along line)
/** Linear grid in pixel. */
private double[] uGrid;
/** Linear grid in line. */
private double[] vGrid;
/** Size of uGrid = nbPixelGrid. */
private int nbPixelGrid;
/** Size of vGrid = nbLineGrid. */
private int nbLineGrid;
// Definition of the associated sensor
/** Current min line. */
private double minLineSensor = Double.NaN;
/** Current max line. */
private double maxLineSensor = Double.NaN;
/** Current sensor name. */
private String sensorName = null;
/**
* Default constructor.
*/
public AtmosphericComputationParameters() {
this.pixelStep = DEFAULT_STEP_PIXEL;
this.lineStep = DEFAULT_STEP_LINE;
}
/** Configuration of the interpolation grid. This grid is associated to the given sensor,
* with the given min and max lines.
* @param sensor line sensor
* @param minLine min line defined for the inverse location
* @param maxLine max line defined for the inverse location
*/
public void configureCorrectionGrid(final LineSensor sensor, final int minLine, final int maxLine) {
// Keep information about the sensor and the required search lines.
// Needed to test if the grid is initialized with this context.
this.minLineSensor = minLine;
this.maxLineSensor = maxLine;
this.sensorName = sensor.getName();
// Compute the number of pixels and lines for the grid (round value is sufficient)
final int sensorNbPxs = sensor.getNbPixels();
this.nbPixelGrid = sensorNbPxs / this.pixelStep;
// check the validity of the min and max lines
if ((maxLine - minLine + 1 - 2 * MARGIN_LINE) < 2 * this.lineStep) {
final String info = ": (maxLine - minLine + 1 - 2*" + MARGIN_LINE + ") < 2*" + this.lineStep;
throw new RuggedException(RuggedMessages.INVALID_RANGE_FOR_LINES, minLine, maxLine, info);
}
this.nbLineGrid = (maxLine - minLine + 1 - 2 * MARGIN_LINE) / this.lineStep;
// CHECKSTYLE: stop UnnecessaryParentheses check
// Compute the linear grids in pixel (u index) and line (v index)
this.uGrid = GridCreation.createLinearGrid(0, (sensorNbPxs - 1), this.nbPixelGrid);
this.vGrid = GridCreation.createLinearGrid((minLine + MARGIN_LINE), (maxLine - MARGIN_LINE), this.nbLineGrid);
// CHECKSTYLE: resume UnnecessaryParentheses check
}
/**
* Set the grid steps in pixel and line (used to compute inverse location).
* Overwrite the default values, for time optimization if necessary.
* @param gridPixelStep grid pixel step for the inverse location computation
* @param gridLineStep grid line step for the inverse location computation
*/
public void setGridSteps(final int gridPixelStep, final int gridLineStep) {
if (gridPixelStep <= 0) {
final String reason = " pixelStep <= 0";
throw new RuggedException(RuggedMessages.INVALID_STEP, gridPixelStep, reason);
}
if (gridLineStep <= 0) {
final String reason = " lineStep <= 0";
throw new RuggedException(RuggedMessages.INVALID_STEP, gridLineStep, reason);
}
this.pixelStep = gridPixelStep;
this.lineStep = gridLineStep;
}
/**
* @return the size of pixel grid
*/
public int getNbPixelGrid() {
return nbPixelGrid;
}
/**
* @return the size of line grid
*/
public int getNbLineGrid() {
return nbLineGrid;
}
/**
* @return the pixel grid
*/
public double[] getUgrid() {
return uGrid.clone();
}
/**
* @return the line grid
*/
public double[] getVgrid() {
return vGrid.clone();
}
/**
* @return the min line used to compute the current grids
*/
public double getMinLineSensor() {
return minLineSensor;
}
/**
* @return the max line used to compute the current grids
*/
public double getMaxLineSensor() {
return maxLineSensor;
}
/**
* @return the sensor name used to compute the current grids
*/
public String getSensorName() {
return sensorName;
}
}