void RealisticCamera::ComputeThickLensApproximation(Float pz[2],
Float fz[2]) const {
// Find height $x$ from optical axis for parallel rays
Float x = .001 * film->diagonal;
// Compute cardinal points for film side of lens system
Ray rScene(Point3f(x, 0, LensFrontZ() + 1), Vector3f(0, 0, -1));
Ray rFilm;
bool ok = TraceLensesFromScene(rScene, &rFilm);
if (!ok)
Severe(
"Unable to trace ray from scene to film for thick lens "
"approximation. Is aperture stop extremely small?");
ComputeCardinalPoints(rScene, rFilm, &pz[0], &fz[0]);
// Compute cardinal points for scene side of lens system
rFilm = Ray(Point3f(x, 0, LensRearZ() - 1), Vector3f(0, 0, 1));
ok = TraceLensesFromFilm(rFilm, &rScene);
if (!ok)
Severe(
"Unable to trace ray from film to scene for thick lens "
"approximation. Is aperture stop extremely small?");
ComputeCardinalPoints(rFilm, rScene, &pz[1], &fz[1]);
}
void Game::spawnAllBlocks() {
float z = -currentLevel->length + 16.0f + 6 * currentStep;
for (int i = 0; i < currentLevel->height; ++i) {
for (int j = 0; j < currentLevel->width; ++j) {
float x = 2.0f * j - currentLevel->width;
float y = i*2.0f + 1.0f;
if (1 == rand() % 2) {
mainBlocks.push_back(std::make_shared<GameObject>(Point3f(x, y, z), 2.0f, SDL_COLOR_BLUE));
}
else {
freeBlockSlots.push_back(Point3f(x, y, z));
}
}
}
int blocksNeeded = currentLevel->width * currentLevel->height - mainBlocks.size();
for (int i = 0; i < blocksNeeded; ++i) {
Point3f p((float)getRandom(-currentLevel->width, currentLevel->width), 4 + (blocksNeeded-i)*2.0f, player->getCenter().z + getRandom(-5, 5));
extraBlocks.push_back(std::make_shared<GameObject>(p, 2.0f, getRandomColor(50, 200)));
}
}
void CameraCalibration::calcBoardCornerPositions(Size boardSize, float squareSize,
vector<Point3f>& corners, Settings::Pattern patternType)
{
corners.clear();
switch (patternType)
{
case Settings::CHESSBOARD:
case Settings::CIRCLES_GRID:
for (int i = 0; i < boardSize.height; ++i)
for (int j = 0; j < boardSize.width; ++j)
corners.push_back(Point3f(float(j*squareSize), float(i*squareSize), 0));
break;
case Settings::ASYMMETRIC_CIRCLES_GRID:
for (int i = 0; i < boardSize.height; i++)
for (int j = 0; j < boardSize.width; j++)
corners.push_back(Point3f(float((2 * j + i % 2)*squareSize), float(i*squareSize), 0));
break;
default:
break;
}
}
Point3f Reprojector::reproject_to_3d(float pt0_x, float pt0_y, float pt1_x, float pt1_y)
{
float disparity_val = abs(pt1_x - pt0_x);
float depth = compute_depth(disparity_val);
Point2f plane_size = compute_plane_size(depth);
float half_plane_width = plane_size.x / 2;
float halfPlaneHeight = plane_size.y / 2;
float real_x = map_val(pt0_x, 0, WIDTH_LARGE, -half_plane_width, half_plane_width);
float real_y = map_val(pt0_y, 0, HEIGHT_LARGE, -halfPlaneHeight, halfPlaneHeight);
return Point3f(real_x * 10, real_y * 10, depth * 10);
}
Level_1::Level_1()
: /*m_floor(Point3f(0.0f, 0.0f, 0.0f),
Vector3f(200.0f, 200.0f, -1.0f)),
m_crate(Point3f(50.0f, 50.0f, 0.0f),
Vector3f(30.0f, 30.0f, 30.0f)),
m_crate1(Point3f(150.0f, 0.0f, 0.0f),
Vector3f(20.0f, 20.0f, 20.0f)),
m_crate2(Point3f(0.0f, 150.0f, 100.0f),
Vector3f(40.0f, 40.0f, 40.0f)),*/
m_player(Camera(Point3f(-200.0f, 0.0f, 50.0f),
Quaternion(),
1.0f, 10000.0f),
Vector3f(0.0f, 0.0f, -39.0f),
12.0f)/*,
m_fire(false)*/
{
m_floor = Crate(Point3f(-200.0f, -200.0f, 0.0f), Vector3f(400.0f, 400.0f, -1.0f));
m_crate = Crate(Point3f(0.0f, 60.0f, 0.0f), Vector3f(30.0f, 30.0f, 30.0f));
//m_crate1 = Crate(Point3f(150.0f, 0.0f, 0.0f), Vector3f(20.0f, 20.0f, 20.0f));
m_crate2 = Crate(Point3f(100.0f, 0.0f, 20.0f), Vector3f(10.0f, 10.0f, 10.0f));
//m_player = Player(Camera(Point3f(0.0f, 0.0f, 50.0f), Quaternion(), 1.0f, 10000.0f), Vector3f(0.0f, 0.0f, -39.0f), 12.0f);
m_fire = false;
set_pausable(true);
}
Point3f Unproject( float xp, float yp, float depth ) const
{
CV_Assert( depth > 0 );
Matx31f x, ray, ret;
x(0) = xp; x(1) = yp; x(2) = 1;
ray = m_inv_K * x;
ray *= depth;
// -z into the screen
ray(2) = -ray(2);
ret = m_inv_R*( ray - m_t );
return Point3f( ret(0), ret(1), ret(2) );
}
void Game::initLevel() {
// clear everything associated with level
mainBlocks.clear();
extraBlocks.clear();
freeBlockSlots.clear();
platforms.clear();
openPlatforms.clear();
// tell the "platform builder" where to start
Point2 firstPlatform(currentLevel->width / 2, 0);
openPlatforms.push_back(firstPlatform);
currentLevel->data[firstPlatform.x][firstPlatform.y] = true;
// return objects to initial state
player->setCenter(Point3f(-1.0f, 1.0f, -currentLevel->length + 6.0f)); // set player at the beginning + 6 blocks for some margin
prize->setCenter(Point3f(-1.0f, 1.0f, currentLevel->length - 2.0f)); // set prize right at the end
prize->setRotate(0, 0, 0);
prize->setScale(1, 1, 1);
currentStep = 0;
worldTimer.reset();
currentCutScene = CutScene::LEVEL_BEGINNING;
}
//导入标定图片，提取角点
bool CSingleCalib::addChessBoardPoints(String *strImageName)
{
cout << "CSingleCalib::addChessBoardPoints !" << endl;
bool bRet = false;
do
{
vector<Point2f> imageCorners;
vector<Point3f> objectCorners;
for (int i = 0; i < ChessBoardSize_h; ++i)
{
for (int j = 0; j < ChessBoardSize_w; ++j)
{
objectCorners.push_back(Point3f(i*SquareWidth, j*SquareWidth, 0));
}
}
cv::Mat image;
for (int i = 1; i <= NImage; ++i)
{
image = imread(*strImageName);
cvtColor(image, grayImage, CV_BGR2GRAY);
bool found = findChessboardCorners(image, ChessBoardSize, imageCorners);
cornerSubPix(grayImage, imageCorners, Size(5, 5), cv::Size(-1, -1),
cv::TermCriteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 20, 0.1));
cout << i << endl;
if (imageCorners.size() != ChessBoardSize.area())
{
cout << "检测的角点数和棋盘格本身的数目不等" << endl;
break;
}
addPoints(imageCorners, objectCorners);
cv::drawChessboardCorners(image, ChessBoardSize, imageCorners, found);
cv::imshow("BoardCorner", image);
cv::waitKey(10);
++strImageName;
}
// cvDestroyWindow("image");
cvDestroyWindow("BoardCorner");
bRet = true;
} while (false);
return bRet;
}
void draw()
{
engine->controller.updateMouse();
pos_x = engine->controller.getMousePos().x;
pos_y = engine->controller.getMousePos().y;
renderer->drawQuad(square,Point3f(pos_x+100,pos_y,0),pos_y*1.0,pos_y*1.0,rot);
renderer->drawQuad(square2,Point3f(pos_x,pos_y,-.01),pos_y*1.0,pos_y*1.0,rot*.9);
renderer->drawQuad(square3,Point3f(pos_x-100,pos_y,-.02),pos_y*1.0,pos_y*1.0,rot*.8);
renderer->drawText("default font","Scale 1",Point3f(100,100,0),ColorRGBA(1,1,1,1),8,1.0);
renderer->drawText("default font","Scale 2",Point3f(100,200,0),ColorRGBA(1,1,1,1),8*2,2.0);
renderer->drawText("default font","Scale 3",Point3f(100,300,0),ColorRGBA(1,1,1,1),8*3,3.0);
renderer->drawText("default font",std::to_string(engine->t).c_str(),Point3f(100,400,0),ColorRGBA(1,1,1,1),8*10,10.0);
renderer->drawBuffer();
}; //executes as often as possible
Float PerspectiveCamera::GenerateRayDifferential(const CameraSample &sample,
RayDifferential *ray) const {
ProfilePhase prof(Prof::GenerateCameraRay);
// Compute raster and camera sample positions
Point3f pFilm = Point3f(sample.pFilm.x, sample.pFilm.y, 0);
Point3f pCamera = RasterToCamera(pFilm);
Vector3f dir = Normalize(Vector3f(pCamera.x, pCamera.y, pCamera.z));
*ray = RayDifferential(Point3f(0, 0, 0), dir);
// Modify ray for depth of field
if (lensRadius > 0) {
// Sample point on lens
Point2f pLens = lensRadius * ConcentricSampleDisk(sample.pLens);
// Compute point on plane of focus
Float ft = focalDistance / ray->d.z;
Point3f pFocus = (*ray)(ft);
// Update ray for effect of lens
ray->o = Point3f(pLens.x, pLens.y, 0);
ray->d = Normalize(pFocus - ray->o);
}
// Compute offset rays for _PerspectiveCamera_ ray differentials
if (lensRadius > 0) {
// Compute _PerspectiveCamera_ ray differentials accounting for lens
// Sample point on lens
Point2f pLens = lensRadius * ConcentricSampleDisk(sample.pLens);
Vector3f dx = Normalize(Vector3f(pCamera + dxCamera));
Float ft = focalDistance / dx.z;
Point3f pFocus = Point3f(0, 0, 0) + (ft * dx);
ray->rxOrigin = Point3f(pLens.x, pLens.y, 0);
ray->rxDirection = Normalize(pFocus - ray->rxOrigin);
Vector3f dy = Normalize(Vector3f(pCamera + dyCamera));
ft = focalDistance / dy.z;
pFocus = Point3f(0, 0, 0) + (ft * dy);
ray->ryOrigin = Point3f(pLens.x, pLens.y, 0);
ray->ryDirection = Normalize(pFocus - ray->ryOrigin);
} else {
ray->rxOrigin = ray->ryOrigin = ray->o;
ray->rxDirection = Normalize(Vector3f(pCamera) + dxCamera);
ray->ryDirection = Normalize(Vector3f(pCamera) + dyCamera);
}
ray->time = Lerp(sample.time, shutterOpen, shutterClose);
ray->medium = medium;
*ray = CameraToWorld(*ray);
ray->hasDifferentials = true;
return 1;
}
void SPHSystem::computeForce()
{
int i, j, s, numNei;
float dij;
float term1, term2;
Point3f vij;
Point3f pf, vf, tf, gf, cf;
//#pragma omp parallel for private( j, nId, numNei, d, term1, term2, dv, pf, vf, tf, gf )
for(i=0; i<p.size(); ++i) {
pf.Set(0,0,0);
vf.Set(0,0,0);
tf.Set(0,0,0);
numNei = p[i]->pq.getSize();
for(s=1; s<=numNei; ++s) {
j = p[i]->pq.queue[s];
if(i==j) continue;
term1 = p[i]->p/(p[i]->d*p[i]->d);
term2 = p[j]->p/(p[j]->d*p[j]->d);
vij = *p[i]-*p[j];
dij = vij.Length();
// pressure force
pf += (term1+term2)*p[j]->m*k->pw1(dij)*vij;
// viscosity force
vf += p[j]->m*k->vw2(dij)*(p[j]->v-p[i]->v);
// surface tension
}
pf = -p[i]->d*pf;
vf = (X/p[i]->d)*vf;
gf = p[i]->d*Point3f(0.0f, -GR, 0.0f);
if(p[i]->n.Length() < ( SIM_DIM==2 ? 0.6f : 3.0f) ) // for 2d < 0.6 , 3d < 3.0
tf.Zero();
else
tf = -p[i]->lapc*p[i]->n.GetNormalized();
p[i]->tf = tf;
p[i]->pf = pf;
p[i]->vf = vf;
p[i]->a = (pf+vf+gf+tf)/p[i]->d;
}
}
SpotLight(const PropertyList &props) :
Emitter()
{
//set the arguments
m_position = props.getPoint("position");
m_intensity = props.getColor("Intensity");
bool useLookAt = props.getBoolean("useLookAt", true);
if(useLookAt){
Vector3f lookPT = props.getPoint("lookAt", Point3f(0.0f, 0.0f, 0.0f));
m_direction = (lookPT - m_position).normalized();
} else {
m_direction = props.getVector("direction");
}
m_theta = props.getFloat("theta");
m_cosFalloffStart = props.getFloat("falloff");
}
void Game::playCutSceneGameWin() {
player->lookAt(Point3f(0, 0, 0));
if (cutSceneTimer.getElapsed() >= 0.075 * __SECOND) {
killPlatform();
player->addScore(SCORE_PER_BLOCK);
}
if (eventSystem->isPressed(Key::SPACE) || platforms.empty()) {
while (!platforms.empty()) {
killPlatform();
player->addScore(SCORE_PER_BLOCK);
}
resetCutScene();
running = false;
}
}
int Get3d_2dPoints(PointCloud<PointXYZ>::ConstPtr cloud_p,
PointCloud<PointXYZ>::ConstPtr cloud_p2,
MatrixXf &x3d,
MatrixXf &x2d,
vector <Point3f>& points3d,
vector <Point2f>& imagePoints){
x3d= MatrixXf::Ones(cloud_p->points.size (),4);
x2d= MatrixXf::Ones(cloud_p2->points.size (),3);
std::cout<<"points selected \n"<<cloud_p->points.size ()<<std::endl;
if (cloud_p->points.size ()!=cloud_p2->points.size ()){
return (-1);
}
int i,j;
for (i=0;i<cloud_p->points.size ();i++){
x3d(i,0)=cloud_p->points[i].x;
x3d(i,1)=cloud_p->points[i].y;
x3d(i,2)=cloud_p->points[i].z;
x3d(i,3)=1;
points3d.push_back(Point3f(x3d(i,0), x3d(i,1), x3d(i,2)));
}
for (i=0;i<cloud_p2->points.size ();i++){
x2d(i,0)=cloud_p2->points[i].x;
x2d(i,1)=cloud_p2->points[i].y;
x2d(i,2)=cloud_p2->points[i].z;
imagePoints.push_back(Point2f(x2d(i,0), x2d(i,1)));
}
return (0);
}
void RealisticCamera::TestExitPupilBounds() const {
Float filmDiagonal = film->diagonal;
static RNG rng;
Float u = rng.UniformFloat();
Point3f pFilm(u * filmDiagonal / 2, 0, 0);
Float r = pFilm.x / (filmDiagonal / 2);
int pupilIndex =
std::min((int)exitPupilBounds.size() - 1,
(int)std::floor(r * (exitPupilBounds.size() - 1)));
Bounds2f pupilBounds = exitPupilBounds[pupilIndex];
if (pupilIndex + 1 < (int)exitPupilBounds.size())
pupilBounds = Union(pupilBounds, exitPupilBounds[pupilIndex + 1]);
// Now, randomly pick points on the aperture and see if any are outside
// of pupil bounds...
for (int i = 0; i < 1000; ++i) {
Point2f pd = ConcentricSampleDisk(
Point2f(rng.UniformFloat(), rng.UniformFloat()));
pd *= RearElementRadius();
Ray testRay(pFilm, Point3f(pd.x, pd.y, 0.f) - pFilm);
Ray testOut;
if (!TraceLensesFromFilm(testRay, &testOut)) continue;
if (!Inside(pd, pupilBounds)) {
fprintf(stderr,
"Aha! (%f,%f) went through, but outside bounds (%f,%f) - "
"(%f,%f)\n",
pd.x, pd.y, pupilBounds.pMin[0], pupilBounds.pMin[1],
pupilBounds.pMax[0], pupilBounds.pMax[1]);
RenderExitPupil(
(Float)pupilIndex / exitPupilBounds.size() * filmDiagonal / 2.f,
0.f, "low.exr");
RenderExitPupil((Float)(pupilIndex + 1) / exitPupilBounds.size() *
filmDiagonal / 2.f,
0.f, "high.exr");
RenderExitPupil(pFilm.x, 0.f, "mid.exr");
exit(0);
}
}
fprintf(stderr, ".");
}
System3d::System3d()
{
scale = 3;
// initiate Mat images
//pmdGrayImage = Mat::zeros(scale*IMG_HEIGHT, scale*IMG_WIDTH, CV_32F);
pmdGrayImage = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_32F);
pmdDepthImage = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_32F);
webcamImage = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8UC3);
pmdChessImage = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8U);
webcamChessImage = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8U);
webcamImageTmp = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8UC3);
pmdTmp = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8U);
webTmp = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8UC3);
undistortPMD = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_32F);
undistortWebcam = Mat::zeros(scale*IMG_WIDTH, scale*IMG_HEIGHT, CV_8UC3);
// calibration matrices
offset = Mat::zeros(4,4,CV_64F);
// cloud parameters
cloud.width = scale*IMG_WIDTH;
cloud.height = scale*IMG_HEIGHT;
cloud.points.resize (cloud.width*cloud.height);
cloud_width = cloud.width;
cloud_height = cloud.height;
// chessboard pattern points coordinate
for (int i=0; i<4; i++)
for (int j=0; j<3; j++)
chessboardPointsWebcam.push_back(Point3f(i*0.0988, j*0.0994, 0)); // poziomo - 9.94 cm, pionowo - 9.88 cm
/*
for (int i=0; i<4; i++)
for (int j=0; j<3; j++)
chessboardPointsPMDcam.push_back(Point3f(i*0.0988*scale, j*0.0994*scale, 0));
*/
calibrated = false;
patternCount = 0;
}
static void longLatLabel(const string& labelText,
double longitude,
double latitude,
const Vec3d& viewRayOrigin,
const Vec3d& viewNormal,
const Vec3d& bodyCenter,
const Quatd& bodyOrientation,
const Vec3f& semiAxes,
float labelOffset,
Renderer* renderer)
{
double theta = degToRad(longitude);
double phi = degToRad(latitude);
Vec3d pos(cos(phi) * cos(theta) * semiAxes.x,
sin(phi) * semiAxes.y,
-cos(phi) * sin(theta) * semiAxes.z);
float nearDist = renderer->getNearPlaneDistance();
pos = pos * (1.0 + labelOffset);
double boundingRadius = max(semiAxes.x, max(semiAxes.y, semiAxes.z));
// Draw the label only if it isn't obscured by the body ellipsoid
double t = 0.0;
if (testIntersection(Ray3d(Point3d(0.0, 0.0, 0.0) + viewRayOrigin, pos - viewRayOrigin),
Ellipsoidd(Vec3d(semiAxes.x, semiAxes.y, semiAxes.z)), t) && t >= 1.0)
{
// Compute the position of the label
Vec3d labelPos = bodyCenter +
(1.0 + labelOffset) * pos * bodyOrientation.toMatrix3();
// Calculate the intersection of the eye-to-label ray with the plane perpendicular to
// the view normal that touches the front of the objects bounding sphere
double planetZ = viewNormal * bodyCenter - boundingRadius;
if (planetZ < -nearDist * 1.001)
planetZ = -nearDist * 1.001;
double z = viewNormal * labelPos;
labelPos *= planetZ / z;
renderer->addObjectAnnotation(NULL, labelText,
Renderer::PlanetographicGridLabelColor,
Point3f((float) labelPos.x, (float) labelPos.y, (float) labelPos.z));
}
}
bool PointerMapper::project_to_plane(Point3f& pt, Point3f& result, float& dist_to_plane)
{
Ray ray = Ray(pt, direction_plane);
float t;
if (ray.intersects(plane, t))
{
const float x = pt.x + t * direction_plane.x;
const float y = pt.y + t * direction_plane.y;
const float z = pt.z + t * direction_plane.z;
result = Point3f(x, y, z);
dist_to_plane = get_distance(result, pt);
return true;
}
return false;
}
void Game::buildPlatforms() {
std::list<Point2> neighbors;
for (auto point : openPlatforms) {
std::list<Point2> tmp = getNeighborPlatforms(point);
for (auto p : tmp)
neighbors.push_back(p);
float x = 2.0f * point.x - currentLevel->width;
float z = 2.0f * point.y - currentLevel->length; // place it the way that level center is always at 0.0.0 origin
// y = -0.1f so that the top of the platforms represent the 0th line in Y - the ground
std::shared_ptr<GameObject> plat = std::make_shared<GameObject>(Point3f(x, -0.1f, z), 2.0f, 0.2f, 2.0f, ResourceManager::getTextureID(_RES_TEX_BRICK));
platforms.push_back(plat);
}
openPlatforms = neighbors;
}
void testApp::updatePointCloud() {
pointCloud.clear();
const unsigned int Xres = 640;
const unsigned int Yres = 480;
Point2d fov = kinectCalibration.getUndistortedIntrinsics().getFov();
float fx = tanf(ofDegToRad(fov.x) / 2) * 2;
float fy = tanf(ofDegToRad(fov.y) / 2) * 2;
Point2d principalPoint = kinectCalibration.getUndistortedIntrinsics().getPrincipalPoint();
cv::Size imageSize = kinectCalibration.getUndistortedIntrinsics().getImageSize();
int w = 640;
int h = 480;
// int w = curKinect.getWidth();
// int h = curKinect.getHeight();
// float* pixels = curKinect.getPixels();
Mat pixels = curKinect;
int i = 0;
/*
principalPoint.x += ofMap(mouseX, 0, ofGetWidth(), -4, 4);
principalPoint.y += ofMap(mouseY, 0, ofGetHeight(), -4, 4);
cout << "fudge: " << ofMap(mouseX, 0, ofGetWidth(), -4, 4) << "x" << ofMap(mouseY, 0, ofGetHeight(), -4, 4) << endl;
*/
for(int y = 0; y < h; y++) {
for(int j = 0; j < w; j++) {
float pixel = curKinect.at<float>(y, j);
if(pixel < 1000) { // the rest is basically noise
int x = Xres - j - 1; // x axis is flipped from depth image
float z = rawToCentimeters(pixel);
float xReal = (((float) x - principalPoint.x) / imageSize.width) * z * fx;
float yReal = (((float) y - principalPoint.y) / imageSize.height) * z * fy;
// add each point into pointCloud
pointCloud.push_back(Point3f(xReal, yReal, z));
}
i++;
}
}
}
/// Unprojects a point from the window to the scene.
Point3f GraphicsView::unproject(qreal x, qreal y, qreal z) const
{
// flip y
y = height() - y;
// adjust point to normalized window coordinates
Eigen::Matrix<float, 4, 1> point;
point[0] = 2 * x / width() - 1;
point[1] = 2 * y / height() - 1;
point[2] = 2 * z - 1;
point[3] = 1;
// map to object-space coordinates
GraphicsTransform transform = projectionTransform() * modelViewTransform();
point = transform.inverseMultiply(point);
point *= 1.0 / point[3];
return Point3f(point[0], point[1], point[2]);
}
void HumanBodyLaser::refine3DPoints(vector<Point3f>& points, vector<Vec3b>& colors, int& validnum)
{
float maxdepth = MAXDEPTH;
float mindepth = MINDEPTH;
int size = points.size();
for(int i = 0; i < size; ++i)
{
if(points[i].z == PT_UNDEFINED) continue;
float z = points[i].z;
if(z < mindepth || z > maxdepth)
{
points[i] = Point3f(PT_UNDEFINED, PT_UNDEFINED, PT_UNDEFINED);
colors[i] = Vec3b(0,0,0);
validnum --;
}
}
}
Point3f RealisticCamera::SampleExitPupil(const Point2f &pFilm,
const Point2f &lensSample,
Float *sampleBoundsArea) const {
// Find exit pupil bound for sample distance from film center
Float rFilm = std::sqrt(pFilm.x * pFilm.x + pFilm.y * pFilm.y);
int rIndex = rFilm / (film->diagonal / 2) * exitPupilBounds.size();
rIndex = std::min((int)exitPupilBounds.size() - 1, rIndex);
Bounds2f pupilBounds = exitPupilBounds[rIndex];
if (sampleBoundsArea) *sampleBoundsArea = pupilBounds.Area();
// Generate sample point inside exit pupil bound
Point2f pLens = pupilBounds.Lerp(lensSample);
// Return sample point rotated by angle of _pFilm_ with $+x$ axis
Float sinTheta = (rFilm != 0) ? pFilm.y / rFilm : 0;
Float cosTheta = (rFilm != 0) ? pFilm.x / rFilm : 1;
return Point3f(cosTheta * pLens.x - sinTheta * pLens.y,
sinTheta * pLens.x + cosTheta * pLens.y, LensRearZ());
}
void Game::playCutSceneLevelBeginning() {
if (cutSceneTimer.getTime() == 0) { // means running for 1st time
// move to level beginning -20 units, so player can see how platforms are being built
dummyCameraObject->moveTo(Point3f(1.0f, 45.0f, -currentLevel->length*1.0f - 20.0f));
dummyCameraObject->lookAt(prize->getCenter());
camera->follow(dummyCameraObject);
}
if (cutSceneTimer.getElapsed() >= 0.075 * __SECOND) {
buildPlatforms();
if (dummyCameraObject->getCenter().y > 7.0f) {
dummyCameraObject->move(Vector3f(0, -1.0f, 0.25f));
}
else {
if (distanceBetween(dummyCameraObject->getCenter(), prize->getCenter()) > 7.5f) {
dummyCameraObject->move(Vector3f(0, 0, 1.5f));
}
else {
cutSceneFrame++;
}
}
dummyCameraObject->lookAt(prize->getCenter());
cutSceneTimer.measure();
}
if (eventSystem->isPressed(Key::SPACE) || (isLevelBuilt() && cutSceneFrame > 0)) {
while (!isLevelBuilt()) {
buildPlatforms();
}
camera->follow(player);
resetCutScene();
spawnAllBlocks();
#ifdef __DEBUG
debug("Level Created, Blocks spawned, CutScene::LEVEL_BEGINNING completed");
#endif
}
}
void AugmentedView::Update(Mat * rgbaImage, Engine * engine)
{
tabs->Draw(rgbaImage);
if (!updateObjectMap.empty())
{
if (engine->communicator != NULL && engine->communicator->IsConnected())
{
for (map<string,ARObjectMessage*>::iterator it = updateObjectMap.begin();it != updateObjectMap.end();it++)
{
LOGD(LOGTAG_ARINPUT,"Sending update for object %s",(*it).first.c_str());
engine->communicator->SendMessage((*it).second);
}
}
updateObjectMap.clear();
}
if (createNext)
{
Point3f cameraPosition = getCameraPosition(projection);
char objectName[100];
sprintf(objectName,"user_obj_%d",objectVector.size()+1);
GLObject * glObject = OpenGLHelper::CreateMultiColorCube(20);
Point3f newLocation = Point3f(0,0,0);
if (testObject != NULL)
newLocation = testObject->position;
ARObject * newObject = new ARObject(glObject, newLocation);
newObject->BoundingSphereRadius = 12;
newObject->objectID = objectName;
if (engine->communicator->IsConnected())
{
engine->communicator->SendMessage(new ARObjectMessage(newObject,true));
}
createNext = false;
objectVector.push_back(newObject);
}
canDraw = true;
}
//////////////////////////////////////////////////////////////////////////
//@intro 初始化当前控件的参数
//////////////////////////////////////////////////////////////////////////
void GLTextureArea::initializeGL() {
readMtlFile();
glClearColor(1.0, 1.0, 1.0, 0);
//glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glOrtho(-2,2,-2,2,-2,2);
trackball.center = Point3f(glmModel->mAvePt[0],glmModel->mAvePt[1],glmModel->mAvePt[2]);
trackball.radius = 1;
trackball.ClearModes();
trackball.modes[0] = NULL;
trackball.modes[Trackball::BUTTON_LEFT] = new PanMode();
//trackball.modes[Trackball::BUTTON_LEFT] = new PlaneMode(0,0,1,0);
trackball.modes[Trackball::KEY_LEFT] = trackball.modes[Trackball::KEY_RIGHT] = trackball.modes[Trackball::KEY_UP] = trackball.modes[Trackball::KEY_DOWN] = new PanMode();
trackball.modes[Trackball::WHEEL] = new ScaleMode();
//trackball.GetView();
trackball.Apply(false);
}
int main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH);
glutInitWindowSize(winW,winH);
glutInitWindowPosition(100,100);
glutCreateWindow("SPH");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutSpecialFunc(specialKeys);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glInit();
simInit();
cam.setPos(0.01f, -PI, 15.0f, Point3f(0.2f,0.2f,0));
cam.moveDrive(-3,-3);
glutMainLoop();
return 0;
}
void ASM_Gaze_Tracker::findBestFrontalFaceShapeIn3D() {
int currentIndex = -1;
vector<vector<Point2f> > pointsSeries = tracker.smodel.matY2pts();
currentIndex = 0;
vector<Point2f> points = pointsSeries[currentIndex];
Point2f center = points[0]*0.5f + points[1]*0.5f;
float normVaue = tracker.annotations.getDistanceBetweenOuterCanthuses()/norm(points[3]-points[2]);
for (int i = 0 ; i < points.size(); i++) {
points[i] =points[i]- center;
points[i] *=normVaue;
}
vector<Point3f> faceFeatures;
for (int i =0 ; i < points.size() ; i ++) {
faceFeatures.push_back(Point3f(points[i].x,points[i].y,0));
}
faceFeatures[4].z = 8;
faceFeatures[5].z = 8;
facialPointsIn3D = faceFeatures;
}
Float RealisticCamera::FocusDistance(Float filmDistance) {
// Find offset ray from film center through lens
Bounds2f bounds = BoundExitPupil(0, .001 * film->diagonal);
Float lu = 0.1f * bounds.pMax[0];
Ray ray;
if (!TraceLensesFromFilm(Ray(Point3f(0, 0, LensRearZ() - filmDistance),
Vector3f(lu, 0, filmDistance)),
&ray)) {
Error(
"Focus ray at lens pos(%f,0) didn't make it through the lenses "
"with film distance %f?!??\n",
lu, filmDistance);
return Infinity;
}
// Compute distance _zFocus_ where ray intersects the principal axis
Float tFocus = -ray.o.x / ray.d.x;
Float zFocus = ray(tFocus).z;
if (zFocus < 0) zFocus = Infinity;
return zFocus;
}
MT::MT(Mat img, Rect2f rect, ostream *os) :
log(os),
image_size(img.size()),
window_size(rect.size()),
feature(image_size),
warp(image_size)
{
warp.set(locate(rect));
float fine_stride = sqrt(window_size.area() / fine_n);
int W = int(floor(window_size.width / (2.0f * fine_stride)));
int H = int(floor(window_size.height / (2.0f * fine_stride)));
for (int y = 0; y <= 2 * H; ++y)
for (int x = 0; x <= 2 * W; ++x)
fine_samples.push_back(Point3f((x - W) * fine_stride, (y - H) * fine_stride, 0.0f));
feature.process(img, 0.0f);
fine_train(warp);
fast_train(warp);
error = 0.0f;
roll = yaw = pitch = 0.0f;
count = N = 0;
}
