bool PointerInfo::projectWindowXYIntoObject(const osg::Vec2d& windowCoord, osg::Vec3d& nearPoint, osg::Vec3d& farPoint) const
{
nearPoint = osg::Vec3d(windowCoord.x(),windowCoord.y(),0.0)*_inverseMVPW;
farPoint = osg::Vec3d(windowCoord.x(),windowCoord.y(),1.0)*_inverseMVPW;
return true;
}
void intersectGridLinesFromSegment(const osg::Vec2d& s0, const osg::Vec2d& s1, std::vector<osg::Vec2d>& list)
{
struct Entry {
float dist;
osg::Vec2d value;
};
osg::Vec2d min(FLT_MAX,FLT_MAX);
osg::Vec2d max(-FLT_MAX,-FLT_MAX);
if(s0.x()<min.x()) min.x() = s0.x();
if(s0.x()>max.x()) max.x() = s0.x();
if(s0.y()<min.y()) min.y() = s0.y();
if(s0.y()>max.y()) max.y() = s0.y();
if(s1.x()<min.x()) min.x() = s1.x();
if(s1.x()>max.x()) max.x() = s1.x();
if(s1.y()<min.y()) min.y() = s1.y();
if(s1.y()>max.y()) max.y() = s1.y();
list.clear();
osg::Vec2d result;
{
int start = static_cast<int>(floor(min[0]));
int stop = static_cast<int>(ceil(max[0]));
double myMin = floor(min[1]);
double myMax = ceil(max[1]);
for (int i = start; i <= stop; i++) {
if (lineIntersect(s0,s1,osg::Vec2d(i,myMin - 1), osg::Vec2d(i,myMax + 1), result)) {
list.push_back(osg::Vec2d(i, result[1]));
}
}
}
{
int start = static_cast<int>(floor(min[1]));
int stop = static_cast<int>(ceil(max[1]));
double myMin = floor(min[0]);
double myMax = ceil(max[0]);
for (int j = start; j <= stop; j++) {
if (lineIntersect(s0,s1,osg::Vec2d(myMin - 1, j), osg::Vec2d(myMax + 1,j ), result)) {
list.push_back(osg::Vec2d(result[0], j));
}
}
}
std::sort(list.begin(), list.end(), less_mag(s0));
}
//--------------------------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------------------------
bool ScreenSpaceHandler::intersect(osg::Vec3d &worldIntersectionPoint, osg::Vec2d const &screenPos)
{
osgUtil::LineSegmentIntersector::Intersections intersections;
opencover::VRViewer::instance()->computeIntersections(
float(screenPos.x()),
float(screenPos.y()),
intersections);
if (intersections.size() > 0)
{
// Intersections are sort by depth
// First object in the set is the nearest
osgUtil::LineSegmentIntersector::Intersection isect = *intersections.begin();
worldIntersectionPoint = isect.getWorldIntersectPoint();
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Reshape subwindow using the subwindows position and size (see note #4)
//-----------------------------------------------------------------------------
bool GlutDisplay::reshapeSubWindow(const osg::Vec2d& position, const osg::Vec2d& size)
{
//std::cout << "reshapeSubWindow(p,s) winID = " << winId << std::endl;
bool ok = false;
if (position.x() >= 0 && position.x() <= 1.0 && position.y() >= 0 && position.y() <= 1.0) {
if (size.x() >= 0 && size.x() <= 1.0 && size.y() >= 0 && size.y() <= 1.0) {
swPosition = position;
swSize = size;
reshapeSubWindow();
ok = true;
}
}
return ok;
}
void DataOutputStream::writeVec2d(const osg::Vec2d& v){
writeDouble(v.x());
writeDouble(v.y());
if (_verboseOutput) std::cout<<"read/writeVec2() ["<<v<<"]"<<std::endl;
}
osg::Matrixd
ImageOverlayEditor::getTransform(const osg::Vec2d& loc)
{
osg::Matrixd matrix;
_imageOverlay->getEllipsoid()->computeLocalToWorldTransformFromLatLongHeight(osg::DegreesToRadians(loc.y()), osg::DegreesToRadians(loc.x()), 0, matrix);
return matrix;
}
void ViewingCore::rotate( osg::Vec2d start, osg::Vec2d dir )
{
if( dir.length2() == 0. )
// No motion
return;
if( _mode == FIRST_PERSON ) {
// Position is constant in 1st person view. Obtain it (for later use)
// *before* we alter the _viewDir.
const osg::Vec3d position = getEyePosition();
// Compute rotation matrix.
osg::Vec3d cross = _viewDir ^ _viewUp;
osg::Matrix m = osg::Matrix::rotate( dir[ 0 ], _viewUp ) *
osg::Matrix::rotate( -dir[ 1 ], cross );
// Re-orient the basis.
_viewDir = _viewDir * m;
_viewUp = _viewUp * m;
// Orthonormalize.
cross = _viewDir ^ _viewUp;
_viewUp = cross ^ _viewDir;
_viewDir.normalize();
_viewUp.normalize();
// Compute the new view center.
_viewCenter = position + ( _viewDir * _viewDistance );
}
else { // THIRD_PERSON
const osg::Matrixd orientMat = getOrientationMatrix();
// Take the spin direction 'dir' and rotate it 90 degrees
// to get our base axis (still in the window plane).
// Simultaneously convert to current view space.
osg::Vec2d screenAxis( -dir[ 1 ], dir[ 0 ] );
const osg::Vec3d baseAxis = osg::Vec3d( screenAxis[ 0 ], screenAxis[ 1 ], 0. ) * orientMat;
osg::Vec3d dir3 = osg::Vec3d( dir[ 0 ], dir[ 1 ], 0. ) * orientMat;
dir3.normalize();
// The distance from center, along with the roll sensitivity,
// tells us how much to rotate the baseAxis (ballTouchAngle) to get
// the actual ballAxis.
const double distance = start.length();
const double rotationDir( ( screenAxis * start > 0. ) ? -1. : 1. );
const double ballTouchAngle = rotationDir * _trackballRollSensitivity * distance;
osg::Vec3d ballAxis = baseAxis * osg::Matrixd::rotate( ballTouchAngle, dir3 );
ballAxis.normalize();
osg::Matrixd m = osg::Matrixd::rotate( -( dir.length() ), ballAxis );
// Re-orient the basis.
_viewDir = _viewDir * m;
_viewUp = _viewUp * m;
// Orthonormalize.
osg::Vec3d cross = _viewDir ^ _viewUp;
_viewUp = cross ^ _viewDir;
_viewDir.normalize();
_viewUp.normalize();
}
}
GeoPoint::GeoPoint( const osg::Vec2d& _input, const SpatialReference* _srs )
: osg::Vec3d( _input.x(), _input.y(), 0.0 )
{
spatial_ref = (SpatialReference*)_srs;
dim = 2;
}
void clampLatitude(osg::Vec2d& l)
{
l.y() = osg::clampBetween( l.y(), -90.0, 90.0);
}
void Horizon3DNode2::updateGeometry()
{
osgGeo::Vec2i fullSize = getSize();
osg::DoubleArray &depthVals = *dynamic_cast<osg::DoubleArray*>(getDepthArray());
double min = +999999.0;
double max = -999999.0;
for(int j = 0; j < fullSize.x(); ++j)
{
for(int i = 0; i < fullSize.y(); ++i)
{
const double val = depthVals.at(i * fullSize.y() + j);
if(isUndef(val))
continue;
min = std::min(val, min);
max = std::max(val, max);
}
}
const double diff = max - min;
std::vector<osg::Vec2d> coords = getCornerCoords();
osg::Vec2d iInc = (coords[2] - coords[0]) / (fullSize.x() - 1);
osg::Vec2d jInc = (coords[1] - coords[0]) / (fullSize.y() - 1);
const osgGeo::Vec2i tileSize(255, 255);
const int compr = 1;
const int hSize = tileSize.x() + 1;
const int vSize = tileSize.y() + 1;
osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array(hSize * vSize);
osg::ref_ptr<osg::DrawElementsUInt> indices =
new osg::DrawElementsUInt(GL_TRIANGLES);
osg::ref_ptr<osg::Vec2Array> tCoords = new osg::Vec2Array(hSize * vSize);
osg::Vec2 texStart(0.0, 0.0);
osg::Vec2 textureTileStep(1.0, 1.0);
for(int i = 0; i < hSize; ++i)
{
for(int j = 0; j < vSize; ++j)
{
osg::Vec2d hor = iInc * i + jInc * j;
(*vertices)[i*vSize+j] = osg::Vec3(hor.x(), hor.y(), 0);
(*tCoords)[i*vSize+j] = texStart + osg::Vec2(
float(i) / (hSize - 1) * textureTileStep.x(),
float(j) / (vSize - 1) * textureTileStep.y()
);
}
}
for(int i = 0; i < hSize - 1; ++i)
{
for(int j = 0; j < vSize - 1; ++j)
{
const int i00 = i*vSize+j;
const int i10 = (i+1)*vSize+j;
const int i01 = i*vSize+(j+1);
const int i11 = (i+1)*vSize+(j+1);
// first triangle
indices->push_back(i00);
indices->push_back(i10);
indices->push_back(i01);
// second triangle
indices->push_back(i10);
indices->push_back(i01);
indices->push_back(i11);
}
}
osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
geom->setVertexArray(vertices.get());
geom->setTexCoordArray(0, tCoords.get());
geom->addPrimitiveSet(indices.get());
osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array;
colors->push_back(osg::Vec4(1.0f, 0.0f, 1.0f, 1.0f)); // needs to be white!
geom->setColorArray(colors.get());
geom->setColorBinding(osg::Geometry::BIND_OVERALL);
// ------------- geom finished ----------------
ShaderUtility su;
su.addDefinition("hasGeomShader");
osg::Program* programGeom = su.createProgram("horizon3d_vert.glsl", "horizon3d_frag.glsl",
"horizon3d_geom.glsl");
ShaderUtility su2;
osg::Program* programNonGeom = su2.createProgram("horizon3d_vert.glsl", "horizon3d_frag.glsl");
int numHTiles = ceil(float(fullSize.x()) / tileSize.x());
int numVTiles = ceil(float(fullSize.y()) / tileSize.y());
for(int hIdx = 0; hIdx < numHTiles; ++hIdx)
{
for(int vIdx = 0; vIdx < numVTiles; ++vIdx)
{
const int hSize2 = hIdx < (numHTiles - 1) ?
(tileSize.x() + 1) : (fullSize.x() - tileSize.x() * (numHTiles - 1)) / compr;
const int vSize2 = vIdx < (numVTiles - 1) ?
(tileSize.y() + 1) : ((fullSize.y() - tileSize.y() * (numVTiles - 1))) / compr;
if(hSize2 == 1 || vSize2 == 1)
continue;
osg::ref_ptr<osg::Image> image = new osg::Image;
image->allocateImage(vSize, hSize, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE);
image->setInternalTextureFormat(GL_LUMINANCE8_ALPHA8);
unsigned short *ptr = reinterpret_cast<unsigned short*>(image->data());
bool hasUndefs = false;
for(int j = 0; j < vSize; ++j)
{
for(int i = 0; i < hSize; ++i)
{
bool defined = false;
if((i < hSize2) && (j < vSize2))
{
int iGlobal = hIdx * tileSize.x() + i;
int jGlobal = vIdx * tileSize.y() + j;
double val = depthVals.at(iGlobal * fullSize.y() + jGlobal);
if(!isUndef(val))
{
*ptr = (val - min) / diff * UCHAR_MAX;
defined = true;
}
}
if(!defined)
{
*ptr = 0xFF00;
hasUndefs = true;
}
ptr++;
}
}
const int i1 = hIdx * tileSize.x();
const int j1 = vIdx * tileSize.y();
const osg::Vec2d start = coords[0] + iInc * i1 + jInc * j1;
const osg::Vec3 shift(start.x(), start.y(), 0);
osg::ref_ptr<osg::Texture2D> heightMap = new osg::Texture2D;
heightMap->setImage(image.get());
osg::ref_ptr<osg::Vec3Array> triangleNormals =
new osg::Vec3Array((hSize - 1) * (vSize - 1) * 2);
for(int i = 0; i < hSize - 1; ++i)
for(int j = 0; j < vSize - 1; ++j)
{
if((i < hSize2 - 1) && (j < vSize2 - 1))
{
int iGlobal = hIdx * tileSize.x() + i;
int jGlobal = vIdx * tileSize.y() + j;
const int i00 = i*vSize+j;
const int i10 = (i+1)*vSize+j;
const int i01 = i*vSize+(j+1);
const int i11 = (i+1)*vSize+(j+1);
osg::Vec3 v00 = (*vertices)[i00] + shift;
osg::Vec3 v10 = (*vertices)[i10] + shift;
osg::Vec3 v01 = (*vertices)[i01] + shift;
osg::Vec3 v11 = (*vertices)[i11] + shift;
const int i00_Global = iGlobal * fullSize.y() + jGlobal;
const int i10_Global = (iGlobal+1) * fullSize.y() + jGlobal;
const int i01_Global = iGlobal * fullSize.y() + (jGlobal+1);
const int i11_Global = (iGlobal+1) * fullSize.y() + (jGlobal+1);
v00.z() = depthVals.at(i00_Global);
v10.z() = depthVals.at(i10_Global);
v01.z() = depthVals.at(i01_Global);
v11.z() = depthVals.at(i11_Global);
if(isUndef(v10.z()) || isUndef(v01.z()))
continue;
// calculate triangle normals
osg::Vec3 norm1 = (v01 - v00) ^ (v10 - v00);
norm1.normalize();
(*triangleNormals)[(i*(vSize-1)+j)*2] = norm1;
osg::Vec3 norm2 = (v10 - v11) ^ (v01 - v11);
norm2.normalize();
(*triangleNormals)[(i*(vSize-1)+j)*2+1] = norm2;
}
}
osg::Image *normalsImage = new osg::Image();
normalsImage->allocateImage(hSize, vSize, 1, GL_RGB, GL_UNSIGNED_BYTE);
GLubyte *normPtr = (GLubyte*)normalsImage->data();
// The following loop calculates normals per vertex. Because
// each vertex might be shared between many triangles(up to 6)
// we find out which triangles this particular vertex is shared
// and then compute the average of normals per triangle.
osg::Vec3 triNormCache[6];
for(int j = 0; j < vSize; ++j)
{
for(int i = 0; i < hSize; ++i)
{
if((i < hSize2) && (j < vSize2))
{
int k = 0;
const int vSizeT = vSize - 1;
// 3
if((i < hSize - 1) && (j < vSize - 1))
{
triNormCache[k++] = (*triangleNormals)[(i*vSizeT+j)*2];
}
// 4, 5
if(i > 0 && j < vSize - 1)
{
triNormCache[k++] = (*triangleNormals)[((i-1)*vSizeT+j)*2];
triNormCache[k++] = (*triangleNormals)[((i-1)*vSizeT+j)*2+1];
}
// 1, 2
if(j > 0 && i < hSize - 1)
{
triNormCache[k++] = (*triangleNormals)[(i*vSizeT+j-1)*2];
triNormCache[k++] = (*triangleNormals)[(i*vSizeT+j-1)*2+1];
}
// 6
if(i > 0 && j > 0)
{
triNormCache[k++] = (*triangleNormals)[((i-1)*vSizeT+j-1)*2+1];
}
if(k > 0)
{
osg::Vec3 norm;
for(int l = 0; l < k; ++l)
norm += triNormCache[l];
norm.normalize();
// scale [-1;1] to [0..255]
#define C_255_OVER_2 127.5
*(normPtr + 0) = GLubyte((norm.x() + 1.0) * C_255_OVER_2);
*(normPtr + 1) = GLubyte((norm.y() + 1.0) * C_255_OVER_2);
*(normPtr + 2) = GLubyte((norm.z() + 1.0) * C_255_OVER_2);
}
}
normPtr += 3;
}
}
osg::ref_ptr<osg::Texture2D> normals = new osg::Texture2D;
normals->setImage(normalsImage);
osg::Geode* geode = new osg::Geode;
geode->addDrawable(geom.get());
// apply vertex shader to shift geometry
osg::StateSet *ss = geode->getOrCreateStateSet();
ss->addUniform(new osg::Uniform("colour", osg::Vec4(0.0f, 0.0f, 1.0f, 1.0f)));
ss->addUniform(new osg::Uniform("depthMin", float(min)));
ss->addUniform(new osg::Uniform("depthDiff", float(diff)));
ss->setTextureAttributeAndModes(1, heightMap.get());
ss->setTextureAttributeAndModes(2, normals.get());
ss->addUniform(new osg::Uniform("heightMap", 1));
ss->addUniform(new osg::Uniform("normals", 2));
const Palette p;
const int sz = p.colorPoints().size();
osg::Uniform *colourPoints = new osg::Uniform(osg::Uniform::FLOAT_VEC4, "colourPoints[0]", 20);
for(int i = 0; i < sz; ++i)
{
osg::Vec3 colour = p.colorPoints().at(i).color;
colourPoints->setElement(i, osg::Vec4(colour, 1.0));
}
ss->addUniform(colourPoints);
osg::Uniform *colourPositions = new osg::Uniform(osg::Uniform::FLOAT, "colourPositions[0]", 20);
for(int i = 0; i < sz; ++i)
{
colourPositions->setElement(i, p.colorPoints().at(i).pos);
}
ss->addUniform(colourPositions);
ss->addUniform(new osg::Uniform("paletteSize", sz));
ss->setAttributeAndModes(hasUndefs ? programGeom : programNonGeom, osg::StateAttribute::ON);
osg::ref_ptr<Horizon3DTileNode2> transform = new Horizon3DTileNode2;
transform->setMatrix(osg::Matrix::translate(osg::Vec3(start, 0)));
transform->setNode(0, geode);
// compute bounding box as our nodes don't have proper vertex information
// and OSG can't deduce bounding sphere for culling
osg::BoundingBox bb(osg::Vec3(start, min),
osg::Vec3(start + iInc * hSize2 + jInc * vSize2, max));
transform->setBoundingSphere(bb);
_nodes.push_back(transform);
}
}
_needsUpdate = false;
}
bool intersects(unsigned level, osg::Vec2d& in_min, osg::Vec2d& in_max)
{
osg::notify(osg::INFO)<<"intersects("<<level<<", min="<<in_min<<" max="<<in_max<<")"<<std::endl;
osg::notify(osg::INFO)<<" _maxLevel="<<_maxLevel<<", _min="<<_min<<" _max="<<_max<<std::endl;
if (level>_maxLevel) return false;
osg::Vec2d union_min, union_max;
// handle mins
if (_min.x()!=DBL_MAX && in_min.x()!=DBL_MAX)
{
// both _min.x() and in_min.x() are defined so use max of two
union_min.x() = _min.x()>in_min.x() ? _min.x() : in_min.x();
}
else
{
// one or both _min.x() and in_min.x() aren't defined so use min of two
union_min.x() = _min.x()<in_min.x() ? _min.x() : in_min.x();
}
if (_min.y()!=DBL_MAX && in_min.y()!=DBL_MAX)
{
// both _min.y() and in_min.y() are defined so use max of two
union_min.y() = _min.y()>in_min.y() ? _min.y() : in_min.y();
}
else
{
// one or both _min.y() and in_min.y() aren't defined so use min of two
union_min.y() = _min.y()<in_min.y() ? _min.y() : in_min.y();
}
// handle maxs
if (_max.x()!=-DBL_MAX && in_max.x()!=-DBL_MAX)
{
// both _max.x() and in_max.x() are defined so use max of two
union_max.x() = _max.x()<in_max.x() ? _max.x() : in_max.x();
}
else
{
// one or both _max.x() and in_max.x() aren't defined so use max of two
union_max.x() = _max.x()>in_max.x() ? _max.x() : in_max.x();
}
if (_max.y()!=-DBL_MAX && in_max.y()!=-DBL_MAX)
{
// both _max.y() and in_max.y() are defined so use max of two
union_max.y() = _max.y()<in_max.y() ? _max.y() : in_max.y();
}
else
{
// one or both _max.y() and in_max.y() aren't defined so use max of two
union_max.y() = _max.y()>in_max.y() ? _max.y() : in_max.y();
}
bool result = union_min.x()<union_max.x() && union_min.y()<union_max.y() ;
osg::notify(osg::INFO)<<" union_min="<<union_min<<" union_max="<<union_max<<" result = "<<result<<std::endl;
return result;
}
bool Triangle2HeightField::clipBoundingBox(const osg::Vec2d& v1, const osg::Vec2d& v2, const osg::Vec2d& v3)
{
osg::Vec2d min(FLT_MAX,FLT_MAX);
osg::Vec2d max(-FLT_MAX,-FLT_MAX);
if(v1.x()<min.x()) min.x() = v1.x();
if(v1.x()>max.x()) max.x() = v1.x();
if(v1.y()<min.y()) min.y() = v1.y();
if(v1.y()>max.y()) max.y() = v1.y();
if(v2.x()<min.x()) min.x() = v2.x();
if(v2.x()>max.x()) max.x() = v2.x();
if(v2.y()<min.y()) min.y() = v2.y();
if(v2.y()>max.y()) max.y() = v2.y();
if(v3.x()<min.x()) min.x() = v3.x();
if(v3.x()>max.x()) max.x() = v3.x();
if(v3.y()<min.y()) min.y() = v3.y();
if(v3.y()>max.y()) max.y() = v3.y();
// clip boundingbox up down left right
if (min[1] > _heightField->getNumRows()-1 ||
max[1] < 0 ||
max[0] < 0 ||
min[0] > _heightField->getNumColumns()-1 )
return true;
return false;
}