int ColorMapBulletNewApproachVolumeSampling(int argc, char** argv, boost::shared_ptr<ElVis::Model> model, unsigned int width, unsigned int height, const std::string& outFilePath)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(100, 100);
glutCreateWindow("fake");
boost::shared_ptr<ElVis::Scene> scene(new ElVis::Scene());
scene->SetModel(model);
boost::shared_ptr<ElVis::Cylinder> cylinder(new ElVis::Cylinder());
cylinder->GetTransformationMatrix()[11] = 2.0;
cylinder->GetTransformationMatrix()[0] = .10001f;
cylinder->GetTransformationMatrix()[5] = .10001f;
cylinder->GetTransformationMatrix()[10] = .4f;
ElVis::PointLight* l = new ElVis::PointLight();
ElVis::Color lightColor;
lightColor.SetRed(.5);
lightColor.SetGreen(.5);
lightColor.SetBlue(.5);
ElVis::WorldPoint lightPos(10.0, 0.0, 0.0);
l->SetColor(lightColor);
l->SetPosition(lightPos);
scene->AddLight(l);
ElVis::Color ambientColor;
ambientColor.SetRed(.5);
ambientColor.SetGreen(.5);
ambientColor.SetBlue(.5);
scene->SetAmbientLightColor(ambientColor);
boost::shared_ptr<ElVis::Triangle> triangle1(new ElVis::Triangle());
triangle1->SetP0(ElVis::WorldPoint(0, -1, 0));
triangle1->SetP1(ElVis::WorldPoint(0, -1, 18));
triangle1->SetP2(ElVis::WorldPoint(0, 1, 18));
boost::shared_ptr<ElVis::Triangle> triangle2(new ElVis::Triangle());
triangle2->SetP0(ElVis::WorldPoint(0, -1, 0));
triangle2->SetP2(ElVis::WorldPoint(0, 1, 0));
triangle2->SetP1(ElVis::WorldPoint(0, 1, 18));
ElVis::Cylinder* cylinderToMap = new ElVis::Cylinder();
cylinderToMap->GetTransformationMatrix()[11] = 0;
cylinderToMap->GetTransformationMatrix()[0] = .1f;
cylinderToMap->GetTransformationMatrix()[5] = .1f;
cylinderToMap->GetTransformationMatrix()[10] = 20.0f;
boost::shared_ptr<ElVis::PrimaryRayModule> primaryRayModule(new ElVis::PrimaryRayModule());
boost::shared_ptr<ElVis::SampleVolumeSamplerObject> t1Sampler(new ElVis::SampleVolumeSamplerObject(triangle1));
boost::shared_ptr<ElVis::SampleVolumeSamplerObject> t2Sampler(new ElVis::SampleVolumeSamplerObject(triangle2));
//boost::shared_ptr<ElVis::SurfaceObject> cylinderSurface(new ElVis::SurfaceObject(cylinder));
boost::shared_ptr<ElVis::SampleVolumeSamplerObject> cylinderSurface(new ElVis::SampleVolumeSamplerObject(cylinder));
primaryRayModule->AddObject(t1Sampler);
primaryRayModule->AddObject(t2Sampler);
primaryRayModule->AddObject(cylinderSurface);
boost::shared_ptr<ElVis::ColorMapperModule> colorMapperModule(new ElVis::ColorMapperModule());
boost::shared_ptr<ElVis::TextureColorMap> textureColorMapper(new ElVis::TextureColorMap(ElVis::GetColorMapPath() + "/diverging257.cmap"));
textureColorMapper->SetMin(-.12);
textureColorMapper->SetMax(0);
colorMapperModule->SetColorMap(textureColorMapper);
ElVis::Camera c;
// Zoomed to region of interest.
//c.SetParameters(ElVis::WorldPoint(.5, 0, 1.5), ElVis::WorldPoint(0, 0, 1.5), ElVis::WorldVector(0, 1, 0));
// Overall view
//c.SetParameters(ElVis::WorldPoint(6, 0, 3.5), ElVis::WorldPoint(0, 0, 3.5), ElVis::WorldVector(0, 1, 0));
//c.SetParameters(ElVis::WorldPoint(1.8, 1.2, 3.0), ElVis::WorldPoint(0, 0, 1), ElVis::WorldVector(0, 1, 0));
c.SetParameters(ElVis::WorldPoint(1.8, .46, 3.7), ElVis::WorldPoint(0, 0, 2.7), ElVis::WorldVector(0, 1, 0));
boost::shared_ptr<ElVis::SceneView> view(new ElVis::SceneView());
view->SetCamera(c);
boost::shared_ptr<ElVis::LightingModule> lighting(new ElVis::LightingModule());
view->AddRenderModule(primaryRayModule);
view->AddRenderModule(colorMapperModule);
view->AddRenderModule(lighting);
view->SetScene(scene);
view->Resize(width, height);
//view->GetScene()->SetEnableOptixTrace(true);
//ElVis::Point<int, ElVis::TwoD> pixel1(10, 10);
//view->GetScene()->SetOptixTracePixelIndex(pixel1);
view->Draw();
//std::cout << "Second pixel." << std::endl;
//ElVis::Point<int, ElVis::TwoD> pixel(10, 1000-10-1);
//view->GetScene()->SetOptixTracePixelIndex(pixel);
//view->Draw();
//ElVis::Point<int, ElVis::TwoD> pixel2(10, 1000-10-1);
//view->GetScene()->SetOptixTracePixelIndex(pixel2);
//view->GetScene()->SetEnableOptixTrace(true);
//view->Draw();
view->WriteColorBufferToFile(outFilePath.c_str());
return 0;
}
bool Breakpoints::eventFilter(QObject *object, QEvent *event)
{
if( object != m_widget )
{
return false;
}
switch (event->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent *me = (QMouseEvent *) event;
QPointF clickPos = me->pos();
for(m_selectedBreakpoint = m_model->GetBreakpoints().begin(); m_selectedBreakpoint != m_model->GetBreakpoints().end(); ++m_selectedBreakpoint)
{
QPainterPath path;
path.addEllipse(pointBoundingRect(m_selectedBreakpoint));
if (path.contains(clickPos))
{
break;
}
}
if (me->button() == Qt::LeftButton)
{
if (m_selectedBreakpoint == m_model->GetBreakpoints().end() )
{
double px, py;
CalculatePercent(clickPos.x(), clickPos.y(), px, py);
ElVis::Color c;
c.SetAlpha(py);
c.SetGreen(1.0);
c.SetRed(1.0);
c.SetBlue(1.0);
m_selectedBreakpoint = m_model->InsertBreakpoint(px, c);
}
}
else if (me->button() == Qt::RightButton)
{
if( m_selectedBreakpoint != m_model->GetBreakpoints().end() )
{
m_model->RemoveBreakpoint(m_selectedBreakpoint);
m_selectedBreakpoint = m_model->GetBreakpoints().end();
}
}
OnSelectedPointChanged(m_selectedBreakpoint);
OnBreakpointsChanged();
return true;
}
break;
case QEvent::MouseButtonRelease:
break;
case QEvent::MouseMove:
if (m_selectedBreakpoint != m_model->GetBreakpoints().end() )
{
const QPointF& point = ((QMouseEvent *)event)->pos();
double px, py;
CalculatePercent(point.x(), point.y(), px, py);
ElVisFloat key = px;
while( m_model->GetBreakpoints().find(key) != m_model->GetBreakpoints().end())
{
key += .00001;
}
ElVis::Color c = (*m_selectedBreakpoint).second.Col;
c.SetAlpha(py);
m_model->RemoveBreakpoint(m_selectedBreakpoint);
m_selectedBreakpoint = m_model->InsertBreakpoint(key, c);
OnBreakpointsChanged();
}
break;
case QEvent::Resize:
{
//QResizeEvent *e = (QResizeEvent *) event;
//if (e->oldSize().width() == 0 || e->oldSize().height() == 0)
// break;
//qreal stretch_x = e->size().width() / qreal(e->oldSize().width());
//qreal stretch_y = e->size().height() / qreal(e->oldSize().height());
//for (int i=0; i<m_points.size(); ++i)
//{
// QPointF p = m_points[i];
// movePoint(i, QPointF(p.x() * stretch_x, p.y() * stretch_y), false);
//}
//update();
break;
}
case QEvent::Paint:
{
ColorMapRect* that_widget = m_widget;
m_widget = 0;
QApplication::sendEvent(object, event);
m_widget = that_widget;
paintPoints();
return true;
}
default:
break;
}
return false;
}
int GenericCLIInterface(int argc, char** argv,
boost::shared_ptr<ElVis::Scene> scene,
boost::shared_ptr<ElVis::Model> model,
boost::shared_ptr<ElVis::ColorMap> colorMap,
unsigned int width, unsigned int height, const std::string& outFilePath, const ElVis::Camera& c)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(100, 100);
glutCreateWindow("fake");
std::cout << "Generic CLI Interface." << std::endl;
const char* isovaluesLabel = "Isovalues";
const char* isosurfaceModuleEnabledLabel = "IsosurfaceModuleEnabled";
const char* volumeRenderingModuleEnabledLabel = "VolumeRenderingModuleEnabled";
const char* contourModuleEnabledLabel = "ContourModuleEnabled";
const char* meshModuleEnabledLabel = "MeshModuleEnabled";
const char* boundarySurfacesLabel = "BoundarySurfaces";
// Volume Rendering labels
const char* integrationTypeLabel = "IntegrationType";
const char* breakpointLabel = "Breakpoints";
const char* colorsLabel = "Colors";
const char* hLabel = "h";
const char* epsilonLabel = "Epsilon";
const char* traceLabel = "EnableTrace";
const char* traceXLabel = "TraceX";
const char* traceYLabel = "TraceY";
const char* trackNumSamplesLabel = "TrackNumSamples";
const char* renderIntegrationTypeLabel = "RenderIntegrationType";
const char* emptySpaceSkippingLabel = "EnableEmptySpaceSkipping";
const char* cutPlaneNormalLabel = "CutPlaneNormal";
const char* cutPlanePointLabel= "CutPlanePoint";
const char* fieldLabel="Field";
const char* numTestsLabel = "NumTests";
std::vector<double> cutPlaneNormal;
std::vector<double> cutPlanePoint;
std::vector<double> breakpoints;
std::vector<double> colors;
std::vector<int> boundarySurfaces;
std::vector<double> isovalues;
bool isosurfaceModuleEnabled = false;
bool volumeRenderingModuleEnabled = false;
bool contourModuleEnabled = false;
bool meshModuleEnabled = false;
unsigned int numTests = 1;
std::string configFile;
int fieldIndex = 0;
boost::program_options::options_description desc("GenericCLIOptions");
desc.add_options()
(isovaluesLabel, boost::program_options::value<std::vector<double> >(&isovalues)->multitoken(), "Isovalues")
(boundarySurfacesLabel, boost::program_options::value<std::vector<int> >(&boundarySurfaces)->multitoken(), "Boundary Surfaces")
(isosurfaceModuleEnabledLabel, boost::program_options::value<bool>(&isosurfaceModuleEnabled), "Isosurface Module Enabled")
(volumeRenderingModuleEnabledLabel, boost::program_options::value<bool>(&volumeRenderingModuleEnabled), "Volume Rendering Module Enabled")
(contourModuleEnabledLabel, boost::program_options::value<bool>(&contourModuleEnabled), "Contour Module Enabled")
(meshModuleEnabledLabel, boost::program_options::value<bool>(&meshModuleEnabled), "Mesh Module Enabled")
(integrationTypeLabel, boost::program_options::value<int>(), "Integration Type")
(breakpointLabel, boost::program_options::value<std::vector<double> >(&breakpoints)->multitoken(), "Breakpoints")
(colorsLabel, boost::program_options::value<std::vector<double> >(&colors)->multitoken(), "Colors")
(hLabel, boost::program_options::value<double>(), "h")
(epsilonLabel, boost::program_options::value<double>(), "Epsilon")
(traceLabel, boost::program_options::value<int>(), "Enable Trace")
(traceXLabel, boost::program_options::value<int>(), "Trace X")
(traceYLabel, boost::program_options::value<int>(), "Trace Y")
(trackNumSamplesLabel, boost::program_options::value<int>(), "Track Num Samples")
(renderIntegrationTypeLabel, boost::program_options::value<int>(), "RenderIntegrationType")
(emptySpaceSkippingLabel, boost::program_options::value<int>(), "EnableEmptySpaceSkipping")
(numTestsLabel, boost::program_options::value<unsigned int>(&numTests), "Number of Tests")
(cutPlaneNormalLabel, boost::program_options::value<std::vector<double> >(&cutPlaneNormal)->multitoken(), "Cut Plane Normal")
(cutPlanePointLabel, boost::program_options::value<std::vector<double> >(&cutPlanePoint)->multitoken(), "Cut Plane Point")
(fieldLabel, boost::program_options::value<int>(&fieldIndex), "Field Index")
;
const char* configFileNameLabel = "ConfigFile";
boost::program_options::options_description configFileOptions("ConfigFileOptions");
configFileOptions.add_options()
(configFileNameLabel, boost::program_options::value<std::string>(&configFile), "Config File")
;
boost::program_options::options_description commandLineOptions("CommandLineOptions");
commandLineOptions.add(desc).add(configFileOptions);
boost::program_options::variables_map vm;
boost::program_options::store(boost::program_options::command_line_parser(argc, argv).options(commandLineOptions).style(boost::program_options::command_line_style::allow_long |
boost::program_options::command_line_style::long_allow_adjacent).allow_unregistered().run(), vm);
boost::program_options::notify(vm);
if( !configFile.empty() )
{
std::ifstream inFile(configFile.c_str());
if( inFile )
{
boost::program_options::store(boost::program_options::parse_config_file(inFile, desc, true), vm);
boost::program_options::notify(vm);
}
inFile.close();
}
#ifdef __GNUC__
system("nvidia-smi");
#endif
ElVis::PointLight* l = new ElVis::PointLight();
ElVis::Color lightColor;
lightColor.SetRed(.5);
lightColor.SetGreen(.5);
lightColor.SetBlue(.5);
ElVis::WorldPoint lightPos(10.0, 0.0, 0.0);
l->SetColor(lightColor);
l->SetPosition(lightPos);
scene->AddLight(l);
ElVis::Color ambientColor;
ambientColor.SetRed(.5);
ambientColor.SetGreen(.5);
ambientColor.SetBlue(.5);
scene->SetAmbientLightColor(ambientColor);
boost::shared_ptr<ElVis::SceneView> view(new ElVis::SceneView());
view->SetCamera(c);
view->SetScalarFieldIndex(fieldIndex);
boost::shared_ptr<ElVis::PrimaryRayModule> primaryRayModule(new ElVis::PrimaryRayModule());
view->AddRenderModule(primaryRayModule);
if( cutPlaneNormal.size() == 3 &&
cutPlanePoint.size() == 3 )
{
ElVis::WorldPoint normal(cutPlaneNormal[0], cutPlaneNormal[1], cutPlaneNormal[2]);
ElVis::WorldPoint p(cutPlanePoint[0], cutPlanePoint[1], cutPlanePoint[2]);
boost::shared_ptr<ElVis::Plane> cutPlane(new ElVis::Plane(normal, p));
boost::shared_ptr<ElVis::SampleVolumeSamplerObject> sampler(new ElVis::SampleVolumeSamplerObject(cutPlane));
primaryRayModule->AddObject(sampler);
}
if( contourModuleEnabled )
{
std::cout << "Contour Module enabled. Number of isovalues = " << isovalues.size() << std::endl;
boost::shared_ptr<ElVis::CutSurfaceContourModule> contourModule(new ElVis::CutSurfaceContourModule());
view->AddRenderModule(contourModule);
for(unsigned int i = 0; i < isovalues.size(); ++i)
{
contourModule->AddIsovalue(isovalues[i]);
}
}
if( meshModuleEnabled )
{
boost::shared_ptr<ElVis::CutSurfaceMeshModule> meshModule(new ElVis::CutSurfaceMeshModule());
view->AddRenderModule(meshModule);
}
if( isosurfaceModuleEnabled )
{
boost::shared_ptr<ElVis::IsosurfaceModule> isosurfaceModule(new ElVis::IsosurfaceModule());
view->AddRenderModule(isosurfaceModule);
for(unsigned int i = 0; i < isovalues.size(); ++i)
{
isosurfaceModule->AddIsovalue(isovalues[i]);
}
}
boost::shared_ptr<ElVis::ColorMapperModule> colorMapperModule(new ElVis::ColorMapperModule());
view->AddRenderModule(colorMapperModule);
colorMapperModule->SetColorMap(colorMap);
if( boundarySurfaces.size() > 0)
{
boost::shared_ptr<ElVis::FaceObject> faceObject(new ElVis::FaceObject(scene));
boost::shared_ptr<ElVis::SampleFaceObject> obj(new ElVis::SampleFaceObject(faceObject));
primaryRayModule->AddObject(obj);
for(int i = 0; i < boundarySurfaces.size(); ++i)
{
std::vector<int> faceIds;
std::string boundaryName;
model->GetBoundarySurface(boundarySurfaces[i], boundaryName, faceIds);
if( faceIds.empty() ) continue;
for(unsigned int j = 0; j < faceIds.size(); ++j)
{
obj->EnableFace(faceIds[j]);
}
}
}
if( volumeRenderingModuleEnabled )
{
if( vm.count(integrationTypeLabel) == 0 )
{
return 1;
}
if( breakpoints.size()*4 != colors.size() )
{
std::cerr << "Invalid transfer specification." << std::endl;
std::cerr << "Breakpoint size " << breakpoints.size() << std::endl;
std::cerr << "Color size " << colors.size() << std::endl;
return 1;
}
ElVis::VolumeRenderingIntegrationType integrationType = static_cast<ElVis::VolumeRenderingIntegrationType>(vm[integrationTypeLabel].as<int>());
double h = .1;
if( vm.count(hLabel) == 1 )
{
h = vm[hLabel].as<double>();
}
double epsilon = .001;
if( vm.count(epsilonLabel) == 1 )
{
epsilon = vm[epsilonLabel].as<double>();
}
bool trackNumSamples = false;
if( vm.count(trackNumSamplesLabel) == 1 )
{
trackNumSamples = (vm[trackNumSamplesLabel].as<int>() == 1);
}
bool renderIntegrationType = false;
if( vm.count(renderIntegrationTypeLabel) == 1 )
{
renderIntegrationType = (vm[renderIntegrationTypeLabel].as<int>() == 1);
}
bool enableEmptySpaceSkipping = true;
if( vm.count(emptySpaceSkippingLabel) == 1 )
{
enableEmptySpaceSkipping = (vm[emptySpaceSkippingLabel].as<int>() == 1);
}
boost::shared_ptr<ElVis::VolumeRenderingModule> m_volumeRenderingModule(new ElVis::VolumeRenderingModule());
m_volumeRenderingModule->SetIntegrationType(integrationType);
m_volumeRenderingModule->SetCompositingStepSize(h);
m_volumeRenderingModule->SetEpsilon(epsilon);
m_volumeRenderingModule->SetRenderIntegrationType(renderIntegrationType);
m_volumeRenderingModule->SetEnableEmptySpaceSkipping(enableEmptySpaceSkipping);
m_volumeRenderingModule->SetTrackNumberOfSamples(trackNumSamples);
// Setup the transfer function.
boost::shared_ptr<ElVis::HostTransferFunction> transferFunction = m_volumeRenderingModule->GetTransferFunction();
for(unsigned int i = 0; i < breakpoints.size(); ++ i)
{
ElVis::Color c(colors[i*4], colors[i*4+1], colors[i*4+2], colors[i*4+3]);
transferFunction->SetBreakpoint(breakpoints[i], c);
}
view->AddRenderModule(m_volumeRenderingModule);
}
boost::shared_ptr<ElVis::LightingModule> lighting(new ElVis::LightingModule());
view->AddRenderModule(lighting);
view->SetScene(scene);
view->Resize(width, height);
// Don't time to take care of initialization artifacts.
view->Draw();
double* times = new double[numTests-1];
for(unsigned int testNum = 1; testNum < numTests; ++testNum)
{
// Repeated redraws will do nothing if we don't signal that the view has changed in some way.
view->OnSceneViewChanged(*view);
ElVis::Timer t = view->Draw();
times[testNum-1] = t.TimePerTest(1);
}
view->WriteColorBufferToFile(outFilePath.c_str());
if( numTests > 1 )
{
ElVis::Stat runtimeStats(times, std::numeric_limits<ElVisFloat>::max(), numTests-1, .95);
std::cout << "Average Time Per Run: " << runtimeStats.Mean << std::endl;
#ifdef __GNUC__
system("nvidia-smi");
#endif
}
return 0;
}