int main(int argc, char *argv[])
{
if (argc != 4)
usage();
database = argv[1];
hSetDb(database);
snpSimpleTable = argv[2];
if (!hTableExistsDb(database, snpSimpleTable))
errAbort("can't get table %s\n", snpSimpleTable);
orthoTable = argv[3];
if (!hTableExistsDb(database, orthoTable))
errAbort("can't get table %s\n", orthoTable);
outputFileHandle = mustOpen("snpOrthoJoin.tab", "w");
missingFileHandle = mustOpen("snpOrthoJoin.missing", "w");
chimpHash = getOrtho(orthoTable, "panTro2");
macaqueHash = getOrtho(orthoTable, "rheMac2");
writeResults(snpSimpleTable);
carefulClose(&outputFileHandle);
carefulClose(&missingFileHandle);
return 0;
}
void ViewingCore::pickCenter( const double ndcX, const double ndcY )
{
// Preserve the view direction.
const osg::Vec3d lastPosition = getEyePosition();
osg::Matrixd p = computeProjection();
osg::Vec4d ccFarPoint( ndcX, ndcY, 1., 1. );
if( !getOrtho() ) {
// Not ortho, so w != 1.0. Multiply by the far plane distance.
// This yields a value in clip coords.
double fovy, aspect, zNear, zFar;
p.getPerspective( fovy, aspect, zNear, zFar );
ccFarPoint *= zFar;
}
// Get inverse view & proj matrices to back-transform the clip coord point.
osg::Matrixd v = getMatrix();
p.invert( p );
osg::Vec4d wc = ccFarPoint * p * v;
osg::Vec3d farPoint( wc.x(), wc.y(), wc.z() );
if( !( intersect( _viewCenter, farPoint ) ) )
osg::notify( osg::WARN ) << "ViewingCore::pickCenter: No intersections." << std::endl;
_viewDistance = ( lastPosition - _viewCenter ).length();
}
void ViewingCore::setPanStart( const double ndcX, const double ndcY )
{
osg::Matrixd p = computeProjection();
// Assume ortho, where ndc far plane == 1 and w always == 1.
osg::Vec4d farPoint = osg::Vec4d( ndcX, ndcY, 1., 1. );
if( !getOrtho() ) {
// Not ortho, so w != 1.0. Multiply by the far plane distance.
// This yields a value in clip coords.
double fovy, aspect, zNear, zFar;
p.getPerspective( fovy, aspect, zNear, zFar );
farPoint *= zFar;
}
// Get inverse view & proj matrices to back-transform the clip coord far point.
osg::Matrixd v = getMatrix();
p.invert( p );
osg::Vec4d wc = farPoint * p * v;
osg::Vec3d wcFarPoint( wc.x(), wc.y(), wc.z() );
// Define world coord plane orthogonal to view, which contains the picked point.
osg::Vec3d pickPoint;
if( !( intersect( pickPoint, wcFarPoint ) ) ) {
// Intersection failed, probably user clicked on background.
// Use _viewCenter to compute plane distance value.
pickPoint = _viewCenter;
osg::notify( osg::DEBUG_FP ) << "Intersection failed. ";
}
_panPlane = osg::Vec4d( _viewDir, -( pickPoint * _viewDir ) );
osg::notify( osg::DEBUG_FP ) << "Pick point " << pickPoint << std::endl;
osg::notify( osg::DEBUG_FP ) << " Plane " << _panPlane << std::endl;
}
void ViewingCore::dolly( const double deltaMovement )
{
if( getOrtho() )
// No dolly in ortho mode
return;
double scale( 1.0 );
if( !( _scene.valid() ) ) {
osg::notify( osg::WARN ) << "ViewingCore::dolly: _scene == NULL." << std::endl;
} else {
// Scale based on model size. TBD this should be under
// app control so that it can be disabled if desired.
const osg::BoundingSphere& bs = _scene->getBound();
scale = bs._radius * .5;
if( _viewDistance > bs._radius )
scale *= ( _viewDistance / bs._radius );
}
_viewDistance += ( deltaMovement * scale );
if( _viewDistance < 0. ) {
double centerDistanceToMove = 1 - _viewDistance;
_viewCenter = _viewCenter + (_viewDir * centerDistanceToMove);
_viewDistance = 1.;
}
}
osg::Vec3d ViewingCore::findDeltaOnPanPlane(double ndcX1, double ndcY1, double ndcX2, double ndcY2)
{
// Get the view volume far plane value, and the distance from
// the near to far plane.
double zNear, zFar;
osg::Matrixd p = computeProjection();
if( getOrtho() ) {
double l, r, b, t;
p.getOrtho( l, r, b, t, zNear, zFar );
} else {
double fovy, aspect;
p.getPerspective( fovy, aspect, zNear, zFar );
}
const double distance = zFar - zNear;
// Create two points, both in NDC space, and lying on the far plane at the back
// of the view volume. One is the xy origin, the other with the passed xy parameters.
osg::Vec4d farPoint0 = osg::Vec4d( ndcX1, ndcY1, 1., 1. );
osg::Vec4d farPoint1 = osg::Vec4d( ndcX2, ndcY2, 1., 1. );
if( !getOrtho() ) {
// Not ortho, so w != 1.0. Multiply by the far plane distance.
// This yields values in clip coordinates.
farPoint0 *= zFar;
farPoint1 *= zFar;
}
// Get inverse view & proj matrices to back-transform the
// two clip coord far points into world space.
osg::Matrixd v = getMatrix();
p.invert( p );
osg::Vec4d wc0 = farPoint0 * p * v;
osg::Vec4d wc1 = farPoint1 * p * v;
// Intersect the two world coord points with the pan plane.
osg::Vec3d result0, result1;
osg::Vec3d p1( wc0.x(), wc0.y(), wc0.z() );
osg::Vec3d p0 = getOrtho() ? p1 - ( _viewDir * distance ) : getEyePosition();
intersectPlaneRay( result0, _panPlane, p0, p1 );
p1 = osg::Vec3d( wc1.x(), wc1.y(), wc1.z() );
p0 = getOrtho() ? p1 - ( _viewDir * distance ) : getEyePosition();
intersectPlaneRay( result1, _panPlane, p0, p1 );
// Subtract the two plane intersection points to get the delta world coord
// motion return
return result1 - result0;
}
void ViewingCore::pan( const double ndcX, const double ndcY )
{
// Get the view volume far plane value, and the distance from
// the near to far plane.
double zNear, zFar;
osg::Matrixd p;
getZNearZFarProj(zNear, zFar, p);
const double distance = zFar - zNear;
// Create two points, both in NDC space, and lying on the far plane at the back
// of the view volume. One is the xy origin, the other with the passed xy parameters.
osg::Vec4d farPoint0 = osg::Vec4d( 0., 0., 1., 1. );
osg::Vec4d farPoint1 = osg::Vec4d( ndcX, ndcY, 1., 1. );
if( !getOrtho() ) {
// Not ortho, so w != 1.0. Multiply by the far plane distance.
// This yields values in clip coordinates.
farPoint0 *= zFar;
farPoint1 *= zFar;
}
// Get inverse view & proj matrices to back-transform the
// two clip coord far points into world space.
osg::Matrixd v = getMatrix();
p.invert( p );
osg::Vec4d wc0 = farPoint0 * p * v;
osg::Vec4d wc1 = farPoint1 * p * v;
// Intersect the two world coord points with the pan plane.
osg::Vec3d result0, result1;
osg::Vec3d p1( wc0.x(), wc0.y(), wc0.z() );
osg::Vec3d p0 = getOrtho() ? p1 - ( _viewDir * distance ) : getEyePosition();
intersectPlaneRay( result0, _panPlane, p0, p1 );
p1 = osg::Vec3d( wc1.x(), wc1.y(), wc1.z() );
p0 = getOrtho() ? p1 - ( _viewDir * distance ) : getEyePosition();
intersectPlaneRay( result1, _panPlane, p0, p1 );
// Subtract the two plane intersection points to get the delta world coord
// motion and move the view center accordingly.
osg::Vec3d delta = result1 - result0;
osg::notify( osg::DEBUG_FP ) << " delta " << delta << std::endl;
_viewCenter -= delta;
}
//-----------------------------------------------------------------------------
// pick() -- Perform for select/pick operation; returns the selected (picked)
// graphic or zero(0) if nothing was selected.
//
// 1) When item == 0, returns nearest (by depth buffer) selected entry.
// 2) When item < 0, returns furthest (by depth buffer) selected entry.
// 3) When item > 0, returns the item'th selected entry or the first entry if
// there are less than 'item' entries
// 4) Returns zero(0) when there are no entries in the select buffer or if the
// Graphic for the select ID is not found.
//-----------------------------------------------------------------------------
BasicGL::Graphic* GlutDisplay::pick(const int item)
{
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT,viewport);
// make sure we are starting at 0, 0
int xm = 0, ym = 0;
getMouse(&xm,&ym);
int x = xm;
int y = viewport[3] - ym;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPickMatrix(x, y, getPickWidth(), getPickHeight(), viewport);
// Get our ortho parameters
GLdouble oLeft(0), oRight(0), oBottom(0), oTop(0), oNear(0), oFar(0);
getOrtho(oLeft, oRight, oBottom, oTop, oNear, oFar);
glOrtho(oLeft, oRight, oBottom, oTop, oNear, oFar);
glMatrixMode(GL_MODELVIEW);
if (getDisplayOrientation() != NORMAL) {
glPushMatrix();
if (getDisplayOrientation() == CW90)
glRotated(-90.0, 0.0, 0.0, 1.0);
else if (getDisplayOrientation() == CCW90)
glRotated(90.0, 0.0, 0.0, 1.0);
else
glRotated(180.0, 0.0, 0.0, 1.0);
}
static const unsigned int MAX_BUFF_SIZE = 1024;
GLuint sbuff[MAX_BUFF_SIZE];
clearSelectBuffer(sbuff,MAX_BUFF_SIZE);
glSelectBuffer(MAX_BUFF_SIZE, sbuff);
glRenderMode(GL_SELECT);
glInitNames();
draw();
GLint hits = glRenderMode(GL_RENDER);
if (getDisplayOrientation() != NORMAL) glPopMatrix();
Graphic* selected = findSelected(hits, sbuff, item);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
return selected;
}
void ViewingCore::getZNearZFarProj(double &zNear, double &zFar, osg::Matrixd &projMat)
{
projMat = computeProjection();
if( getOrtho() ) {
double l, r, b, t;
projMat.getOrtho( l, r, b, t, zNear, zFar );
} else {
double fovy, aspect;
projMat.getPerspective( fovy, aspect, zNear, zFar );
}
}
bool ViewingCore::getStartPoint(osg::Vec3d & startPoint, const osg::Vec3d farPoint, const double ndcX, const double ndcY)
{
if( !( _scene.valid() ) ) {
osg::notify( osg::WARN ) << "ViewingCore::intersect: _scene == NULL." << std::endl;
return( false );
}
const osg::BoundingSphere& bs = _scene->getBound();
const double distance = _viewDistance + bs._radius;
startPoint = getOrtho() ? farPoint - ( _viewDir * distance * 2. ) : getEyePosition();
return true;
}
int main(int argc, char *argv[])
/* generate snpOrtho table from snp ortho file */
/* combine with snp table */
{
if (argc != 4)
usage();
hSetDb(argv[1]);
if (!hTableExistsDb(argv[1], argv[2]))
errAbort("can't get table %s\n", argv[2]);
if (!fileExists(argv[3]))
errAbort("can't find %s\n", argv[3]);
orthoHash = getOrtho(argv[3]);
writeResults(argv[2]);
return 0;
}
BasicGL::Graphic* FoxDisplay::pick(const int mouseX, const int mouseY, const int item)
{
GLint viewport[4];
// get our canvas and make it current
getCanvas()->makeCurrent();
//glGetIntegerv(GL_VIEWPORT,viewport);
getViewport(&viewport[0], &viewport[1], &viewport[2], &viewport[3]);
int x = mouseX;
int y = mouseY;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPickMatrix(x, y, 10, 10, viewport);
GLdouble tl = 0, tr = 0, tb = 0, tt = 0, tn = 0, tf = 0;
getOrtho(tl, tr, tb, tt, tn, tf);
glOrtho(tl, tr, tb, tt, tn, tf);
//std::cout << "viewport is " << viewport[2] << " " << viewport[3] << std::endl;
glMatrixMode(GL_MODELVIEW);
GLuint sbuff[100];
clearSelectBuffer(sbuff,100);
glSelectBuffer(100, sbuff);
glRenderMode(GL_SELECT);
draw();
glRenderMode(GL_RENDER);
printSelectBuffer(sbuff,100);
Graphic* selected = findSelected(sbuff,100,item);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
getCanvas()->makeNonCurrent();
return selected;
}
osg::Vec3d ViewingCore::getFarPoint(const double ndcX, const double ndcY)
{
osg::Matrixd p = computeProjection();
osg::Vec4d ccFarPoint( ndcX, ndcY, 1., 1. );
if( !getOrtho() ) {
// Not ortho, so w != 1.0. Multiply by the far plane distance.
// This yields a value in clip coords.
double fovy, aspect, zNear, zFar;
p.getPerspective( fovy, aspect, zNear, zFar );
ccFarPoint *= zFar;
}
// Get inverse view & proj matrices to back-transform the clip coord point.
osg::Matrixd v = getMatrix();
p.invert( p );
osg::Vec4d wc = ccFarPoint * p * v;
osg::Vec3d farPoint( wc.x(), wc.y(), wc.z() );
return farPoint;
}
bool ViewingCore::intersect( osg::Vec3d& result, const osg::Vec3d& farPoint )
{
if( !( _scene.valid() ) ) {
osg::notify( osg::WARN ) << "ViewingCore::intersect: _scene == NULL." << std::endl;
return( false );
}
const osg::BoundingSphere& bs = _scene->getBound();
const double distance = _viewDistance + bs._radius;
osg::Vec3d startPoint = getOrtho() ? farPoint - ( _viewDir * distance * 2. ) : getEyePosition();
osgUtil::LineSegmentIntersector* intersector = new osgUtil::LineSegmentIntersector(
startPoint, farPoint );
osgUtil::IntersectionVisitor intersectVisitor( intersector, NULL );
_scene->accept( intersectVisitor );
osgUtil::LineSegmentIntersector::Intersections& intersections = intersector->getIntersections();
if( intersections.empty() )
return( false );
const osgUtil::LineSegmentIntersector::Intersection& intersection = *( intersections.begin() );
result = intersection.getWorldIntersectPoint();
return( true );
}
Camera ViewData::getCamera() const
{
if( _view.getMode() == eq::View::MODE_STEREO )
return CAM_STEREO;
return getOrtho() ? CAM_ORTHO : CAM_PERSPECTIVE;
}
/*! \brief Set orthogonality flag
*/
inline void setOrtho(const int flag) const {
*is_ortho = flag;
static char *test = getenv("HMAT_TEST_ORTHO");
if (flag && test) assert(getOrtho() == testOrtho());
}
