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; }