DensityRegion::DensityRegion(const Spectrum &sa,
const Spectrum &ss, float gg,
const Spectrum &emit,
const Transform &VolumeToWorld)
: sig_a(sa), sig_s(ss), le(emit), g(gg) {
WorldToVolume = VolumeToWorld.GetInverse();
}
COREDLL void pbrtCamera(const string &name,
const ParamSet ¶ms) {
VERIFY_OPTIONS("Camera");
renderOptions->CameraName = name;
renderOptions->CameraParams = params;
renderOptions->WorldToCamera = curTransform;
namedCoordinateSystems["camera"] =
curTransform.GetInverse();
}
// Shape Method Definitions
Shape::Shape(const Transform &o2w, bool ro)
: ObjectToWorld(o2w), WorldToObject(o2w.GetInverse()),
reverseOrientation(ro),
transformSwapsHandedness(o2w.SwapsHandedness()) {
// Update shape creation statistics
static StatsCounter nShapesMade("Geometry",
"Total shapes created");
++nShapesMade;
}
// HomogeneousVolume Public Methods
HomogeneousVolume(const Spectrum &sa, const Spectrum &ss, float gg,
const Spectrum &emit, const BBox &e,
const Transform &v2w) {
WorldToVolume = v2w.GetInverse();
sig_a = sa;
sig_s = ss;
g = gg;
le = emit;
extent = e;
}
Transform operator!( const Transform& t )
{
return t.GetInverse();
}
/*
* Fun flux analysis
*/
void FluxAnalysis::RunFluxAnalysis( QString nodeURL, QString surfaceSide, unsigned long nOfRays, bool increasePhotonMap, int heightDivisions, int widthDivisions )
{
m_surfaceURL = nodeURL;
m_surfaceSide = surfaceSide;
//Delete a photonCounts
if( m_photonCounts && m_photonCounts != 0 )
{
for( int h = 0; h < m_heightDivisions; h++ )
{
delete[] m_photonCounts[h];
}
delete[] m_photonCounts;
}
m_photonCounts = 0;
m_heightDivisions = heightDivisions;
m_widthDivisions = widthDivisions;
//Check if there is a scene
if ( !m_pCurrentScene ) return;
//Check if there is a transmissivity defined
TTransmissivity* transmissivity = 0;
if ( !m_pCurrentScene->getPart( "transmissivity", false ) ) transmissivity = 0;
else
transmissivity = static_cast< TTransmissivity* > ( m_pCurrentScene->getPart( "transmissivity", false ) );
//Check if there is a rootSeparator InstanceNode
if( !m_pRootSeparatorInstance ) return;
InstanceNode* sceneInstance = m_pRootSeparatorInstance->GetParent();
if ( !sceneInstance ) return;
//Check if there is a light and is properly configured
if ( !m_pCurrentScene->getPart( "lightList[0]", false ) )return;
TLightKit* lightKit = static_cast< TLightKit* >( m_pCurrentScene->getPart( "lightList[0]", false ) );
InstanceNode* lightInstance = sceneInstance->children[0];
if ( !lightInstance ) return;
if( !lightKit->getPart( "tsunshape", false ) ) return;
TSunShape* sunShape = static_cast< TSunShape * >( lightKit->getPart( "tsunshape", false ) );
if( !lightKit->getPart( "icon", false ) ) return;
TLightShape* raycastingSurface = static_cast< TLightShape * >( lightKit->getPart( "icon", false ) );
if( !lightKit->getPart( "transform" ,false ) ) return;
SoTransform* lightTransform = static_cast< SoTransform * >( lightKit->getPart( "transform" ,false ) );
//Check if there is a random generator is defined.
if( !m_pRandomDeviate || m_pRandomDeviate== 0 ) return;
//Check if the surface and the surface side defined is suitable
if( CheckSurface() == false || CheckSurfaceSide() == false ) return;
//Create the photon map where photons are going to be stored
if( !m_pPhotonMap || !increasePhotonMap )
{
if( m_pPhotonMap ) m_pPhotonMap->EndStore( -1 );
delete m_pPhotonMap;
m_pPhotonMap = new TPhotonMap();
m_pPhotonMap->SetBufferSize( HUGE_VAL );
m_tracedRays = 0;
m_wPhoton = 0;
m_totalPower = 0;
}
QVector< InstanceNode* > exportSuraceList;
QModelIndex nodeIndex = m_pCurrentSceneModel->IndexFromNodeUrl( m_surfaceURL );
if( !nodeIndex.isValid() ) return;
InstanceNode* surfaceNode = m_pCurrentSceneModel->NodeFromIndex( nodeIndex );
if( !surfaceNode || surfaceNode == 0 ) return;
exportSuraceList.push_back( surfaceNode );
//UpdateLightSize();
TSeparatorKit* concentratorRoot = static_cast< TSeparatorKit* >( m_pCurrentScene->getPart( "childList[0]", false ) );
if ( !concentratorRoot ) return;
SoGetBoundingBoxAction* bbAction = new SoGetBoundingBoxAction( SbViewportRegion() ) ;
concentratorRoot->getBoundingBox( bbAction );
SbBox3f box = bbAction->getXfBoundingBox().project();
delete bbAction;
bbAction = 0;
BBox sceneBox;
if( !box.isEmpty() )
{
sceneBox.pMin = Point3D( box.getMin()[0], box.getMin()[1], box.getMin()[2] );
sceneBox.pMax = Point3D( box.getMax()[0], box.getMax()[1], box.getMax()[2] );
if( lightKit ) lightKit->Update( sceneBox );
}
m_pCurrentSceneModel->UpdateSceneModel();
//Compute bounding boxes and world to object transforms
trf::ComputeSceneTreeMap( m_pRootSeparatorInstance, Transform( new Matrix4x4 ), true );
m_pPhotonMap->SetConcentratorToWorld( m_pRootSeparatorInstance->GetIntersectionTransform() );
QStringList disabledNodes = QString( lightKit->disabledNodes.getValue().getString() ).split( ";", QString::SkipEmptyParts );
QVector< QPair< TShapeKit*, Transform > > surfacesList;
trf::ComputeFistStageSurfaceList( m_pRootSeparatorInstance, disabledNodes, &surfacesList );
lightKit->ComputeLightSourceArea( m_sunWidthDivisions, m_sunHeightDivisions, surfacesList );
if( surfacesList.count() < 1 ) return;
QVector< long > raysPerThread;
int maximumValueProgressScale = 100;
unsigned long t1 = nOfRays/ maximumValueProgressScale;
for( int progressCount = 0; progressCount < maximumValueProgressScale; ++ progressCount )
raysPerThread<< t1;
if( ( t1 * maximumValueProgressScale ) < nOfRays ) raysPerThread<< ( nOfRays - ( t1* maximumValueProgressScale) );
Transform lightToWorld = tgf::TransformFromSoTransform( lightTransform );
lightInstance->SetIntersectionTransform( lightToWorld.GetInverse() );
// Create a progress dialog.
QProgressDialog dialog;
dialog.setLabelText( QString("Progressing using %1 thread(s)..." ).arg( QThread::idealThreadCount() ) );
// Create a QFutureWatcher and conncect signals and slots.
QFutureWatcher< void > futureWatcher;
QObject::connect(&futureWatcher, SIGNAL(finished()), &dialog, SLOT(reset()));
QObject::connect(&dialog, SIGNAL(canceled()), &futureWatcher, SLOT(cancel()));
QObject::connect(&futureWatcher, SIGNAL(progressRangeChanged(int, int)), &dialog, SLOT(setRange(int, int)));
QObject::connect(&futureWatcher, SIGNAL(progressValueChanged(int)), &dialog, SLOT(setValue(int)));
QMutex mutex;
QMutex mutexPhotonMap;
QFuture< void > photonMap;
if( transmissivity )
photonMap = QtConcurrent::map( raysPerThread, RayTracer( m_pRootSeparatorInstance,
lightInstance, raycastingSurface, sunShape, lightToWorld,
transmissivity,
*m_pRandomDeviate,
&mutex, m_pPhotonMap, &mutexPhotonMap,
exportSuraceList ) );
else
photonMap = QtConcurrent::map( raysPerThread, RayTracerNoTr( m_pRootSeparatorInstance,
lightInstance, raycastingSurface, sunShape, lightToWorld,
*m_pRandomDeviate,
&mutex, m_pPhotonMap, &mutexPhotonMap,
exportSuraceList ) );
futureWatcher.setFuture( photonMap );
// Display the dialog and start the event loop.
dialog.exec();
futureWatcher.waitForFinished();
m_tracedRays += nOfRays;
double irradiance = sunShape->GetIrradiance();
double inputAperture = raycastingSurface->GetValidArea();
m_wPhoton = double ( inputAperture * irradiance ) / m_tracedRays;
UpdatePhotonCounts();
}