You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
522 lines
17 KiB
522 lines
17 KiB
/*
|
|
**************************************************************************
|
|
description
|
|
--------------------
|
|
copyright : (C) 2003 by Leon Pennington
|
|
email : leon@leonscape.co.uk
|
|
**************************************************************************
|
|
|
|
**************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
**************************************************************************/
|
|
|
|
|
|
#include "pmglobalphotons.h"
|
|
#include "pmxmlhelper.h"
|
|
#include "pmmemento.h"
|
|
#include "pmenumproperty.h"
|
|
#include "pmglobalphotonsedit.h"
|
|
|
|
#include <klocale.h>
|
|
|
|
const double spacingDefault = 0.01;
|
|
const int countDefault = 20000;
|
|
const int gatherMinDefault = 20;
|
|
const int gatherMaxDefault = 100;
|
|
const int mediaMaxStepsDefault = 0;
|
|
const double mediaFactorDefault = 1.0;
|
|
const double jitterDefault = 0.4;
|
|
const int maxTraceLevelDefault = 0;
|
|
const double adcBailoutDefault = 0.01;
|
|
const double autostopDefault = 0.0;
|
|
const double expandIncreaseDefault = 0.2;
|
|
const int expandMinDefault = 40;
|
|
const double radiusGatherDefault = 0.0;
|
|
const double radiusGatherMultiDefault = 1.0;
|
|
const double radiusMediaDefault = 0.0;
|
|
const double radiusMediaMultiDefault = 1.0;
|
|
|
|
PMDefinePropertyClass( PMGlobalPhotons, PMGlobalPhotonsProperty );
|
|
PMDefineEnumPropertyClass( PMGlobalPhotons, PMGlobalPhotons::PMNumberType, PMNumberProperty );
|
|
|
|
PMMetaObject* PMGlobalPhotons::s_pMetaObject = 0;
|
|
PMObject* createNewGlobalPhotons( PMPart* part )
|
|
{
|
|
return new PMGlobalPhotons( part );
|
|
}
|
|
|
|
PMGlobalPhotons::PMGlobalPhotons( PMPart* part ) : Base( part )
|
|
{
|
|
m_numberType = Spacing;
|
|
m_spacing = spacingDefault;
|
|
m_count = countDefault;
|
|
m_gatherMin = gatherMinDefault;
|
|
m_gatherMax = gatherMaxDefault;
|
|
m_mediaMaxSteps = mediaMaxStepsDefault;
|
|
m_mediaFactor = mediaFactorDefault;
|
|
m_jitter = jitterDefault;
|
|
m_maxTraceLevelGlobal = true;
|
|
m_maxTraceLevel = maxTraceLevelDefault;
|
|
m_adcBailoutGlobal = true;
|
|
m_adcBailout = adcBailoutDefault;
|
|
m_autostop = autostopDefault;
|
|
m_expandIncrease = expandIncreaseDefault;
|
|
m_expandMin = expandMinDefault;
|
|
m_radiusGather = radiusGatherDefault;
|
|
m_radiusGatherMulti = radiusGatherMultiDefault;
|
|
m_radiusMedia = radiusMediaDefault;
|
|
m_radiusMediaMulti = radiusMediaMultiDefault;
|
|
}
|
|
|
|
PMGlobalPhotons::PMGlobalPhotons( const PMGlobalPhotons& p )
|
|
: Base( p )
|
|
{
|
|
m_numberType = p.m_numberType;
|
|
m_spacing = p.m_spacing;
|
|
m_count = p.m_count;
|
|
m_gatherMin = p.m_gatherMin;
|
|
m_gatherMax = p.m_gatherMax;
|
|
m_mediaMaxSteps = p.m_mediaMaxSteps;
|
|
m_mediaFactor = p.m_mediaFactor;
|
|
m_jitter = p.m_jitter;
|
|
m_maxTraceLevelGlobal = p.m_maxTraceLevelGlobal;
|
|
m_maxTraceLevel = p.m_maxTraceLevel;
|
|
m_adcBailoutGlobal = p.m_adcBailoutGlobal;
|
|
m_adcBailout = p.m_adcBailout;
|
|
m_autostop = p.m_autostop;
|
|
m_expandIncrease = p.m_expandIncrease;
|
|
m_expandMin = p.m_expandMin;
|
|
m_radiusGather = p.m_radiusGather;
|
|
m_radiusGatherMulti = p.m_radiusGatherMulti;
|
|
m_radiusMedia = p.m_radiusMedia;
|
|
m_radiusMediaMulti = p.m_radiusMediaMulti;
|
|
}
|
|
|
|
PMGlobalPhotons::~PMGlobalPhotons( )
|
|
{
|
|
}
|
|
|
|
PMMetaObject* PMGlobalPhotons::metaObject( ) const
|
|
{
|
|
if( !s_pMetaObject )
|
|
{
|
|
s_pMetaObject = new PMMetaObject( "GlobalPhotons", Base::metaObject( ),
|
|
createNewGlobalPhotons );
|
|
|
|
PMNumberProperty* p1 = new PMNumberProperty( "numberType",
|
|
&PMGlobalPhotons::setNumberType, &PMGlobalPhotons::numberType );
|
|
p1->addEnumValue( "Spacing", Spacing );
|
|
p1->addEnumValue( "Count", Count );
|
|
s_pMetaObject->addProperty( p1 );
|
|
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "spacing",
|
|
&PMGlobalPhotons::setSpacing, &PMGlobalPhotons::spacing ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "count",
|
|
&PMGlobalPhotons::setCount, &PMGlobalPhotons::count ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "gatherMin",
|
|
&PMGlobalPhotons::setGatherMin, &PMGlobalPhotons::gatherMin ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "gatherMax",
|
|
&PMGlobalPhotons::setGatherMax, &PMGlobalPhotons::gatherMax ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "mediaMaxSteps",
|
|
&PMGlobalPhotons::setMediaMaxSteps, &PMGlobalPhotons::mediaMaxSteps ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "mediaFactor",
|
|
&PMGlobalPhotons::setMediaFactor, &PMGlobalPhotons::mediaFactor ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "jitter",
|
|
&PMGlobalPhotons::setJitter, &PMGlobalPhotons::jitter ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "maxTraceLevelGlobal",
|
|
&PMGlobalPhotons::setMaxTraceLevelGlobal, &PMGlobalPhotons::maxTraceLevelGlobal ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "maxTraceLevel",
|
|
&PMGlobalPhotons::setMaxTraceLevel, &PMGlobalPhotons::maxTraceLevel ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "adcBailoutGlobal",
|
|
&PMGlobalPhotons::setAdcBailoutGlobal, &PMGlobalPhotons::adcBailoutGlobal ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "adcBailout",
|
|
&PMGlobalPhotons::setAdcBailout, &PMGlobalPhotons::adcBailout ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "autostop",
|
|
&PMGlobalPhotons::setAutostop, &PMGlobalPhotons::autostop ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "expandIncrease",
|
|
&PMGlobalPhotons::setExpandIncrease, &PMGlobalPhotons::expandIncrease ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "expandMin",
|
|
&PMGlobalPhotons::setExpandMin, &PMGlobalPhotons::expandMin ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusGather",
|
|
&PMGlobalPhotons::setRadiusGather, &PMGlobalPhotons::radiusGather ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusGatherMulti",
|
|
&PMGlobalPhotons::setRadiusGatherMulti, &PMGlobalPhotons::radiusGatherMulti ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusMedia",
|
|
&PMGlobalPhotons::setRadiusMedia, &PMGlobalPhotons::radiusMedia ) );
|
|
s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusMediaMulti",
|
|
&PMGlobalPhotons::setRadiusMediaMulti, &PMGlobalPhotons::radiusMediaMulti ) );
|
|
}
|
|
return s_pMetaObject;
|
|
}
|
|
|
|
void PMGlobalPhotons::cleanUp( ) const
|
|
{
|
|
if( s_pMetaObject )
|
|
{
|
|
delete s_pMetaObject;
|
|
s_pMetaObject = 0;
|
|
}
|
|
Base::cleanUp( );
|
|
}
|
|
|
|
TQString PMGlobalPhotons::description( ) const
|
|
{
|
|
return i18n( "global photons" );
|
|
}
|
|
|
|
void PMGlobalPhotons::serialize( TQDomElement& e, TQDomDocument& ) const
|
|
{
|
|
if( m_numberType == Spacing )
|
|
{
|
|
e.setAttribute( "number_type", "spacing" );
|
|
e.setAttribute( "spacing", m_spacing );
|
|
}
|
|
else
|
|
{
|
|
e.setAttribute( "number_type", "count" );
|
|
e.setAttribute( "count", m_count );
|
|
}
|
|
|
|
e.setAttribute( "gather_min", m_gatherMin );
|
|
e.setAttribute( "gather_max", m_gatherMax );
|
|
e.setAttribute( "media_max_steps", m_mediaMaxSteps );
|
|
e.setAttribute( "media_factor", m_mediaFactor );
|
|
e.setAttribute( "jitter", m_jitter );
|
|
e.setAttribute( "max_trace_level_global", m_maxTraceLevelGlobal );
|
|
e.setAttribute( "max_trace_level", m_maxTraceLevel );
|
|
e.setAttribute( "adc_bailout_global", m_adcBailoutGlobal );
|
|
e.setAttribute( "adc_bailout", m_adcBailout );
|
|
e.setAttribute( "autostop", m_autostop );
|
|
e.setAttribute( "expand_increase", m_expandIncrease );
|
|
e.setAttribute( "expand_min", m_expandMin );
|
|
e.setAttribute( "radius_gather", m_radiusGather );
|
|
e.setAttribute( "radius_gather_multi", m_radiusGatherMulti );
|
|
e.setAttribute( "radius_media", m_radiusMedia );
|
|
e.setAttribute( "radius_media_multi", m_radiusMediaMulti );
|
|
}
|
|
|
|
void PMGlobalPhotons::readAttributes( const PMXMLHelper& h )
|
|
{
|
|
TQString str;
|
|
|
|
str = h.stringAttribute( "number_type", "spacing" );
|
|
if( str == "count" )
|
|
m_numberType = Count;
|
|
else
|
|
m_numberType = Spacing;
|
|
|
|
m_spacing = h.doubleAttribute( "spacing", spacingDefault );
|
|
m_count = h.intAttribute( "count", countDefault );
|
|
m_gatherMin = h.intAttribute( "gather_min", gatherMinDefault );
|
|
m_gatherMax = h.intAttribute( "gather_max", gatherMaxDefault );
|
|
m_mediaMaxSteps = h.intAttribute( "media_max_steps", mediaMaxStepsDefault );
|
|
m_mediaFactor = h.doubleAttribute( "media_factor", mediaFactorDefault );
|
|
m_jitter = h.doubleAttribute( "jitter", jitterDefault );
|
|
m_maxTraceLevelGlobal = h.boolAttribute( "max_trace_level_global", true );
|
|
m_maxTraceLevel = h.intAttribute( "max_trace_level", maxTraceLevelDefault );
|
|
m_adcBailoutGlobal = h.boolAttribute( "adc_bailout_global", true );
|
|
m_adcBailout = h.doubleAttribute( "adc_bailout", adcBailoutDefault );
|
|
m_autostop = h.doubleAttribute( "autostop", autostopDefault );
|
|
m_expandIncrease = h.doubleAttribute( "expand_increase", expandIncreaseDefault );
|
|
m_expandMin = h.intAttribute( "expand_min", expandMinDefault );
|
|
m_radiusGather = h.doubleAttribute( "radius_gather", radiusGatherDefault );
|
|
m_radiusGatherMulti = h.doubleAttribute( "radius_gather_multi",
|
|
radiusGatherMultiDefault );
|
|
|
|
m_radiusMedia = h.doubleAttribute( "radius_media", radiusMediaDefault );
|
|
m_radiusMediaMulti = h.doubleAttribute( "radius_media_multi",
|
|
radiusMediaMultiDefault );
|
|
}
|
|
|
|
void PMGlobalPhotons::setNumberType( PMNumberType nt )
|
|
{
|
|
if( nt != m_numberType )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMNumberTypeID, m_numberType );
|
|
m_numberType = nt;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setSpacing( double s )
|
|
{
|
|
if( s != m_spacing )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMSpacingID, m_spacing );
|
|
m_spacing = s;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setCount( int c )
|
|
{
|
|
if( c != m_count )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMCountID, m_count );
|
|
m_count = c;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setGatherMin( int gm )
|
|
{
|
|
if( gm > m_gatherMax )
|
|
{
|
|
kdError( PMArea ) << "Gather Minimum > Gather Maximum in PMGlobalPhotons::setGatherMin\n";
|
|
gm = m_gatherMax;
|
|
}
|
|
|
|
if( gm != m_gatherMin )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMGatherMinID, m_gatherMin );
|
|
m_gatherMin = gm;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setGatherMax( int gm )
|
|
{
|
|
if( gm < m_gatherMin )
|
|
{
|
|
kdError( PMArea ) << "Gather Maximum < Gather Minimum in PMGlobalPhotons::setGatherMax\n";
|
|
gm = m_gatherMin;
|
|
}
|
|
|
|
if( gm != m_gatherMax )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMGatherMaxID, m_gatherMax );
|
|
m_gatherMax = gm;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setMediaMaxSteps( int mms )
|
|
{
|
|
if( mms != m_mediaMaxSteps )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMMediaMaxStepsID, m_mediaMaxSteps );
|
|
m_mediaMaxSteps = mms;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setMediaFactor( double mf )
|
|
{
|
|
if( mf != m_mediaFactor )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMMediaFactorID, m_mediaFactor );
|
|
m_mediaFactor = mf;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setJitter( double j )
|
|
{
|
|
if( j != m_jitter )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMJitterID, m_jitter );
|
|
m_jitter = j;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setMaxTraceLevelGlobal( bool mtlg )
|
|
{
|
|
if( mtlg != m_maxTraceLevelGlobal )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData(
|
|
s_pMetaObject, PMMaxTraceLevelGlobalID, m_maxTraceLevelGlobal );
|
|
m_maxTraceLevelGlobal = mtlg;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setMaxTraceLevel( int mtl )
|
|
{
|
|
if( mtl != m_maxTraceLevel )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMMaxTraceLevelID, m_maxTraceLevel );
|
|
m_maxTraceLevel = mtl;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setAdcBailoutGlobal( bool abg )
|
|
{
|
|
if( abg != m_adcBailoutGlobal )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData(
|
|
s_pMetaObject, PMAdcBailoutGlobalID, m_adcBailoutGlobal );
|
|
m_adcBailoutGlobal = abg;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setAdcBailout( double ab )
|
|
{
|
|
if( ab != m_adcBailout )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMAdcBailoutID, m_adcBailout );
|
|
m_adcBailout = ab;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setAutostop( double a )
|
|
{
|
|
if( a != m_autostop )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMAutostopID, m_autostop );
|
|
m_autostop = a;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setExpandIncrease( double ei )
|
|
{
|
|
if( ei != m_expandIncrease )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMExpandIncreaseID, m_expandIncrease );
|
|
m_expandIncrease = ei;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setExpandMin( int em )
|
|
{
|
|
if(em != m_expandMin )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMExpandMinID, m_expandMin );
|
|
m_expandMin = em;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setRadiusGather( double rg )
|
|
{
|
|
if ( rg != m_radiusGather )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusGather );
|
|
m_radiusGather = rg;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setRadiusGatherMulti( double rgm )
|
|
{
|
|
if ( rgm != m_radiusGatherMulti )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusGatherMulti );
|
|
m_radiusGatherMulti = rgm;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setRadiusMedia( double rm )
|
|
{
|
|
if ( rm != m_radiusMedia )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusMedia );
|
|
m_radiusMedia = rm;
|
|
}
|
|
}
|
|
|
|
void PMGlobalPhotons::setRadiusMediaMulti( double rmm )
|
|
{
|
|
if ( rmm != m_radiusMediaMulti )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusMediaMulti );
|
|
m_radiusMediaMulti = rmm;
|
|
}
|
|
}
|
|
|
|
PMDialogEditBase* PMGlobalPhotons::editWidget( TQWidget* parent ) const
|
|
{
|
|
return new PMGlobalPhotonsEdit( parent );
|
|
}
|
|
|
|
void PMGlobalPhotons::restoreMemento( PMMemento* s )
|
|
{
|
|
PMMementoDataIterator it( s );
|
|
PMMementoData* data;
|
|
|
|
for( ; it.current( ); ++it )
|
|
{
|
|
data = it.current( );
|
|
if( data->objectType( ) == s_pMetaObject )
|
|
{
|
|
switch( data->valueID( ) )
|
|
{
|
|
case PMNumberTypeID:
|
|
setNumberType( ( PMNumberType ) ( data->intData( ) ) );
|
|
break;
|
|
case PMSpacingID:
|
|
setSpacing( data->doubleData( ) );
|
|
break;
|
|
case PMCountID:
|
|
setCount( data->intData( ) );
|
|
break;
|
|
case PMGatherMinID:
|
|
setGatherMin( data->intData( ) );
|
|
break;
|
|
case PMGatherMaxID:
|
|
setGatherMax( data->intData( ) );
|
|
break;
|
|
case PMMediaMaxStepsID:
|
|
setMediaMaxSteps( data->intData( ) );
|
|
break;
|
|
case PMMediaFactorID:
|
|
setMediaFactor( data->doubleData( ) );
|
|
break;
|
|
case PMJitterID:
|
|
setJitter( data->doubleData( ) );
|
|
break;
|
|
case PMMaxTraceLevelGlobalID:
|
|
setMaxTraceLevelGlobal( data->boolData( ) );
|
|
break;
|
|
case PMMaxTraceLevelID:
|
|
setMaxTraceLevel( data->intData( ) );
|
|
break;
|
|
case PMAdcBailoutGlobalID:
|
|
setAdcBailoutGlobal( data->boolData( ) );
|
|
break;
|
|
case PMAdcBailoutID:
|
|
setAdcBailout( data->doubleData( ) );
|
|
break;
|
|
case PMAutostopID:
|
|
setAutostop( data->doubleData( ) );
|
|
break;
|
|
case PMExpandIncreaseID:
|
|
setExpandIncrease( data->doubleData( ) );
|
|
break;
|
|
case PMExpandMinID:
|
|
setExpandMin( data->intData( ) );
|
|
break;
|
|
case PMRadiusGatherID:
|
|
setRadiusGather( data->doubleData( ) );
|
|
break;
|
|
case PMRadiusGatherMultiID:
|
|
setRadiusGatherMulti( data->doubleData( ) );
|
|
break;
|
|
case PMRadiusMediaID:
|
|
setRadiusMedia( data->doubleData( ) );
|
|
break;
|
|
case PMRadiusMediaMultiID:
|
|
setRadiusMediaMulti( data->doubleData( ) );
|
|
break;
|
|
default:
|
|
kdError( PMArea ) << "Wrong ID in PMRadiosity::restoreMemento\n";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Base::restoreMemento( s );
|
|
}
|