RawImage* ScaleFilter::ProcessInput(CommandLineArgModel* arg, RawImage* image)
{
ScaleFilterModel* model = (ScaleFilterModel*)arg->ParsedModel;
double value = model->Scale;
if (value == 0) return new RawImage(0, 0);
if (value < 1) return scaleDown(value, image);
if (value > 1) return scaleUp(value, image);
return image;
}
/**
* FUNCTION NAME: checkFalsePositiveRate
*
* DESCRIPTION: This function checks the current false positive rate of the FBF
* and decides whether to trigger dynamic resizing
*/
void FBF::checkFalsePositiveRate() {
trace.funcEntry("FBF::checkFalsePositiveRate");
double currentFPR = checkEffectiveFPR();
if ( currentFPR > thresholdFraction * maxTolerableFPR ) {
scaleUp();
}
else if ( currentFPR <= safeThresholdFraction * maxTolerableFPR ) {
scaleDown();
}
trace.funcExit("FBF::checkFalsePositiveRate");
}
void HelpWebView::wheelEvent(QWheelEvent *e)
{
if (e->modifiers()& Qt::ControlModifier)
{
e->accept();
e->delta() > 0 ? scaleUp() : scaleDown();
}
else
{
QWebView::wheelEvent(e);
}
}
void ImageViewer::createActions()
{
this->saveAct = new QAction(tr("&Save"), this);
saveAct->setShortcut(tr("Ctrl+S"));
connect(saveAct, SIGNAL(triggered()), this, SLOT(saveImage()));
exitAct = new QAction(tr("Sa&lir"), this);
exitAct->setShortcut(tr("Ctrl+Q"));
connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
zoomInAct = new QAction(tr("Zoom &In (25%)"), this);
zoomInAct->setShortcut(tr("Ctrl++"));
connect(zoomInAct, SIGNAL(triggered()), this, SLOT(scaleUp()));
zoomOutAct = new QAction(tr("Zoom &Out (25%)"), this);
zoomOutAct->setShortcut(tr("Ctrl+-"));
connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(scaleDown()));
}
b2Vec2 World::scaleDown(const b2Vec2 & v)
{
b2Vec2 t = v;
scaleDown(t.x, t.y);
return t;
}
void World::setGravity(float x, float y)
{
world->SetGravity(scaleDown(b2Vec2(x, y)));
}
osg::Node* createScene()
{
osg::Group* scene = new osg::Group;
unsigned int numColumns = 38;
unsigned int numRows = 39;
unsigned int r;
unsigned int c;
osg::Vec3 origin(0.0f,0.0f,0.0f);
osg::Vec3 size(1000.0f,1000.0f,250.0f);
osg::Vec3 scaleDown(1.0f/size.x(),1.0f/size.y(),1.0f/size.z());
// ---------------------------------------
// Set up a StateSet to texture the objects
// ---------------------------------------
osg::StateSet* stateset = new osg::StateSet();
osg::Uniform* originUniform = new osg::Uniform("terrainOrigin",origin);
stateset->addUniform(originUniform);
osg::Uniform* sizeUniform = new osg::Uniform("terrainSize",size);
stateset->addUniform(sizeUniform);
osg::Uniform* scaleDownUniform = new osg::Uniform("terrainScaleDown",scaleDown);
stateset->addUniform(scaleDownUniform);
osg::Uniform* terrainTextureSampler = new osg::Uniform("terrainTexture",0);
stateset->addUniform(terrainTextureSampler);
osg::Uniform* baseTextureSampler = new osg::Uniform("baseTexture",1);
stateset->addUniform(baseTextureSampler);
osg::Uniform* treeTextureSampler = new osg::Uniform("treeTexture",1);
stateset->addUniform(treeTextureSampler);
// compute z range of z values of grid data so we can scale it.
float min_z = FLT_MAX;
float max_z = -FLT_MAX;
for(r=0;r<numRows;++r)
{
for(c=0;c<numColumns;++c)
{
min_z = osg::minimum(min_z,vertex[r+c*numRows][2]);
max_z = osg::maximum(max_z,vertex[r+c*numRows][2]);
}
}
float scale_z = size.z()/(max_z-min_z);
osg::Image* terrainImage = new osg::Image;
terrainImage->allocateImage(numColumns,numRows,1,GL_LUMINANCE, GL_FLOAT);
terrainImage->setInternalTextureFormat(GL_LUMINANCE_FLOAT32_ATI);
for(r=0;r<numRows;++r)
{
for(c=0;c<numColumns;++c)
{
*((float*)(terrainImage->data(c,r))) = (vertex[r+c*numRows][2]-min_z)*scale_z;
}
}
osg::Texture2D* terrainTexture = new osg::Texture2D;
terrainTexture->setImage(terrainImage);
terrainTexture->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::NEAREST);
terrainTexture->setFilter(osg::Texture2D::MAG_FILTER, osg::Texture2D::NEAREST);
terrainTexture->setResizeNonPowerOfTwoHint(false);
stateset->setTextureAttributeAndModes(0,terrainTexture,osg::StateAttribute::ON);
osg::ref_ptr<osg::Image> image = osgDB::readRefImageFile("Images/lz.rgb");
if (image)
{
osg::Texture2D* texture = new osg::Texture2D;
texture->setImage(image);
stateset->setTextureAttributeAndModes(1,texture,osg::StateAttribute::ON);
}
{
std::cout<<"Creating terrain...";
osg::Geode* geode = new osg::Geode();
geode->setStateSet( stateset );
{
osg::Program* program = new osg::Program;
stateset->setAttribute(program);
#if 1
// use inline shaders
///////////////////////////////////////////////////////////////////
// vertex shader using just Vec4 coefficients
char vertexShaderSource[] =
"uniform sampler2D terrainTexture;\n"
"uniform vec3 terrainOrigin;\n"
"uniform vec3 terrainScaleDown;\n"
"\n"
"varying vec2 texcoord;\n"
"\n"
"void main(void)\n"
"{\n"
" texcoord = gl_Vertex.xy - terrainOrigin.xy;\n"
" texcoord.x *= terrainScaleDown.x;\n"
" texcoord.y *= terrainScaleDown.y;\n"
"\n"
" vec4 position;\n"
" position.x = gl_Vertex.x;\n"
" position.y = gl_Vertex.y;\n"
" position.z = texture2D(terrainTexture, texcoord).r;\n"
" position.w = 1.0;\n"
" \n"
" gl_Position = gl_ModelViewProjectionMatrix * position;\n"
" gl_FrontColor = vec4(1.0,1.0,1.0,1.0);\n"
"}\n";
//////////////////////////////////////////////////////////////////
// fragment shader
//
char fragmentShaderSource[] =
"uniform sampler2D baseTexture; \n"
"varying vec2 texcoord;\n"
"\n"
"void main(void) \n"
"{\n"
" gl_FragColor = texture2D( baseTexture, texcoord); \n"
"}\n";
program->addShader(new osg::Shader(osg::Shader::VERTEX, vertexShaderSource));
program->addShader(new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource));
#else
// get shaders from source
program->addShader(osg::Shader::readShaderFile(osg::Shader::VERTEX, osgDB::findDataFile("shaders/terrain.vert")));
program->addShader(osg::Shader::readShaderFile(osg::Shader::FRAGMENT, osgDB::findDataFile("shaders/terrain.frag")));
#endif
// get shaders from source
}
{
osg::Geometry* geometry = new osg::Geometry;
osg::Vec3Array& v = *(new osg::Vec3Array(numColumns*numRows));
osg::Vec4ubArray& color = *(new osg::Vec4ubArray(1));
color[0].set(255,255,255,255);
float rowCoordDelta = size.y()/(float)(numRows-1);
float columnCoordDelta = size.x()/(float)(numColumns-1);
float rowTexDelta = 1.0f/(float)(numRows-1);
float columnTexDelta = 1.0f/(float)(numColumns-1);
osg::Vec3 pos = origin;
osg::Vec2 tex(0.0f,0.0f);
int vi=0;
for(r=0;r<numRows;++r)
{
pos.x() = origin.x();
tex.x() = 0.0f;
for(c=0;c<numColumns;++c)
{
v[vi].set(pos.x(),pos.y(),pos.z());
pos.x()+=columnCoordDelta;
tex.x()+=columnTexDelta;
++vi;
}
pos.y() += rowCoordDelta;
tex.y() += rowTexDelta;
}
geometry->setVertexArray(&v);
geometry->setColorArray(&color, osg::Array::BIND_OVERALL);
for(r=0;r<numRows-1;++r)
{
osg::DrawElementsUShort& drawElements = *(new osg::DrawElementsUShort(GL_QUAD_STRIP,2*numColumns));
geometry->addPrimitiveSet(&drawElements);
int ei=0;
for(c=0;c<numColumns;++c)
{
drawElements[ei++] = (r+1)*numColumns+c;
drawElements[ei++] = (r)*numColumns+c;
}
}
geometry->setInitialBound(osg::BoundingBox(origin, origin+size));
geode->addDrawable(geometry);
scene->addChild(geode);
}
}
std::cout<<"done."<<std::endl;
return scene;
}
