void FrustumCulling::ComputeFrustum(
double horizontalFOV, double verticalFOV,
double nearPlaneDist, double farPlaneDist
)
{
// view vector for the camera - third column of the orientation matrix
Eigen::Vector3d view = orientation_.col( 2 );
// up vector for the camera - second column of the orientation matix
Eigen::Vector3d up = -orientation_.col( 1 );
// right vector for the camera - first column of the orientation matrix
Eigen::Vector3d right = orientation_.col( 0 );
float vfov_rad = float (verticalFOV * M_PI / 180); // degrees to radians
float hfov_rad = float (horizontalFOV * M_PI / 180); // degrees to radians
float np_h = float (2 * tan (vfov_rad / 2) * nearPlaneDist); // near plane height
float np_w = float (2 * tan (hfov_rad / 2) * nearPlaneDist); // near plane width
float fp_h = float (2 * tan (vfov_rad / 2) * farPlaneDist); // far plane height
float fp_w = float (2 * tan (hfov_rad / 2) * farPlaneDist); // far plane width
Eigen::Vector3d fp_c (position_ + view * farPlaneDist); // far plane center
fp_tl = Eigen::Vector3d(fp_c + (up * fp_h / 2) - (right * fp_w / 2)); // Top left corner of the far plane
fp_tr = Eigen::Vector3d(fp_c + (up * fp_h / 2) + (right * fp_w / 2)); // Top right corner of the far plane
fp_bl = Eigen::Vector3d(fp_c - (up * fp_h / 2) - (right * fp_w / 2)); // Bottom left corner of the far plane
fp_br = Eigen::Vector3d(fp_c - (up * fp_h / 2) + (right * fp_w / 2)); // Bottom right corner of the far plane
Eigen::Vector3d np_c (position_ + view * nearPlaneDist); // near plane center
Eigen::Vector3d np_tr (np_c + (up * np_h / 2) + (right * np_w / 2)); // Top right corner of the near plane
Eigen::Vector3d np_bl (np_c - (up * np_h / 2) - (right * np_w / 2)); // Bottom left corner of the near plane
Eigen::Vector3d np_br (np_c - (up * np_h / 2) + (right * np_w / 2)); // Bottom right corner of the near plane
Eigen::Vector3d fp_b_vec = fp_bl - fp_br;
Eigen::Vector3d fp_normal = fp_b_vec.cross(fp_tr - fp_br); // Far plane equation - cross product of the perpendicular edges of the far plane
farPlane_.head( 3 ) = fp_normal;
farPlane_[ 3 ] = -fp_c.dot( fp_normal );
Eigen::Vector3d np_b_vec = np_tr - np_br;
Eigen::Vector3d np_normal = np_b_vec.cross(np_bl - np_br); // Near plane equation - cross product of the perpendicular edges of the near plane
nearPlane_.head( 3 ) = np_normal;
nearPlane_[3] = -np_c.dot( np_normal );
Eigen::Vector3d a (fp_bl - position_); // Vector connecting the camera and far plane bottom left
Eigen::Vector3d b (fp_br - position_); // Vector connecting the camera and far plane bottom right
Eigen::Vector3d c (fp_tr - position_); // Vector connecting the camera and far plane top right
Eigen::Vector3d d (fp_tl - position_); // Vector connecting the camera and far plane top left
// Frustum and the vectors a, b, c and d. 'position_' is the position of the camera
// _________
// /| . |
// d / | c . |
// / | __._____|
// / / . .
// a <---/-/ . .
// / / . . b
// / .
// .
// T
//
// std::cout << "a: " << a << std::endl;
// std::cout << "d: " << d << std::endl;
// std::cout << "d: " << T << std::endl;
Eigen::Vector3d rightPlane_normal = b.cross (c);
rightPlane_.head( 3 ) = rightPlane_normal;
rightPlane_[3] = -position_.dot( rightPlane_normal );
Eigen::Vector3d leftPlane_normal = d.cross (a);
leftPlane_.head( 3 ) = leftPlane_normal;
leftPlane_[3] = -position_.dot( leftPlane_normal );
Eigen::Vector3d topPlane_normal = c.cross (d);
topPlane_.head( 3 ) = topPlane_normal;
topPlane_[3] = -position_.dot( topPlane_normal );
Eigen::Vector3d bottomPlane_normal = a.cross (b);
bottomPlane_.head( 3 ) = bottomPlane_normal;
bottomPlane_[3] = -position_.dot( bottomPlane_normal );
// std::cout << "leftPlane_normal: " << leftPlane_normal << std::endl;
// std::cout << "nearPlane_:" << std::endl << nearPlane_ << std::endl;
// std::cout << "farPlane_:" << std::endl << farPlane_ << std::endl;
// std::cout << "leftPlane_:" << std::endl << leftPlane_ << std::endl;
// std::cout << "rightPlane_:" << std::endl << rightPlane_ << std::endl;
// std::cout << "topPlane_:" << std::endl << topPlane_ << std::endl;
// std::cout << "bottomPlane_:" << std::endl << bottomPlane_ << std::endl;
}
void infer_slope(const QUESO::FullEnvironment & env) {
// Statistical Inverse Problem: Compute posterior pdf for slope 'm' and y-intercept c
// Step 1: Instantiate the parameter space
QUESO::VectorSpace<> paramSpace(env, "param_", 2, NULL); // 2 since we have a 2D problem
// Step 2: Parameter domain
QUESO::GslVector paramMinValues(paramSpace.zeroVector());
QUESO::GslVector paramMaxValues(paramSpace.zeroVector());
paramMinValues[0] = 2.;
paramMaxValues[0] = 5.;
paramMinValues[1] = 3.;
paramMaxValues[1] = 7.;
QUESO::BoxSubset<> paramDomain("param_", paramSpace, paramMinValues, paramMaxValues);
// Step 3: Instantiate likelihood
Likelihood<> lhood("like_", paramDomain);
// Step 4: Define the prior RV
QUESO::UniformVectorRV<> priorRv("prior_", paramDomain);
// Step 5: Instantiate the inverse problem
QUESO::GenericVectorRV<> postRv("post_", paramSpace);
QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, lhood, postRv);
// Step 6: Solve the inverse problem
// Randomly sample for the initial state?
QUESO::GslVector paramInitials(paramSpace.zeroVector());
priorRv.realizer().realization(paramInitials);
// Initialize the Cov matrix:
QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
proposalCovMatrix(0,0) = std::pow(std::abs(paramInitials[0]) / 20.0, 2.0);
proposalCovMatrix(1,1) = std::pow(std::abs(paramInitials[1]) / 20.0, 2.0);
ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix);
// Using the posterior pdfs for m and c, compute 'y' at a given 'x'
// Step 1: Instantiate the qoi space
QUESO::VectorSpace<> qoiSpace(env, "qoi_", 1, NULL);
// Step 2: Instantiate the parameter domain
// Not necessary here because the posterior from SIP is used as the RV for SFP
// Step 3: Instantiate the qoi object to be used by QUESO
Qoi<> qoi("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the posterior as RV
// Step 5: Instantiate the forward problem
QUESO::GenericVectorRV<> qoiRv("qoi_", qoiSpace);
QUESO::StatisticalForwardProblem<> fp("", NULL, postRv, qoi, qoiRv);
// Step 6: Solve the forward problem
std::cout << "Solving the SFP with Monte Carlo" << std::endl << std::endl;
fp.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sfp_lineSlope_qoi_seq_post.txt");
// SENSITIVITY ANALYSIS
// For m
Qoi_m<> qoi_m("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the prior as RV for sensitivity analysis
// Step 5: Instantiate the forward problem
QUESO::StatisticalForwardProblem<> fp_m("", NULL, priorRv, qoi_m, qoiRv);
// Step 6: Solve the forward problem
fp_m.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_m.txt");
// For c
Qoi_c<> qoi_c("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the prior as RV for sensitivity analysis
// Step 5: Instantiate the forward problem
QUESO::StatisticalForwardProblem<> fp_c("", NULL, priorRv, qoi_c, qoiRv);
// Step 6: Solve the forward problem
fp_c.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_c.txt");
// For both, m and c
Qoi_mc<> qoi_mc("qoi_", paramDomain, qoiSpace);
// Step 4: Define the input RV
// Not required because we use the prior as RV for sensitivity analysis
// Step 5: Instantiate the forward problem
QUESO::StatisticalForwardProblem<> fp_mc("", NULL, priorRv, qoi_mc, qoiRv);
// Step 6: Solve the forward problem
fp_mc.solveWithMonteCarlo(NULL);
system("mv outputData/sfp_lineSlope_qoi_seq.txt outputData/sense_mc.txt");
}
