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.
tdegraphics/kpovmodeler/pmcamera.cpp

770 lines
22 KiB

/*
**************************************************************************
description
--------------------
copyright : (C) 2000-2001 by Andreas Zehender
email : zehender@kde.org
**************************************************************************
**************************************************************************
* *
* 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 "pmcamera.h"
#include "pmxmlhelper.h"
#include "pmcameraedit.h"
#include "pmmemento.h"
#include "pmviewstructure.h"
#include "pm3dcontrolpoint.h"
#include "pmvectorcontrolpoint.h"
#include "pmenumproperty.h"
#include <klocale.h>
PMDefinePropertyClass( PMCamera, PMCameraProperty );
PMDefineEnumPropertyClass( PMCamera, PMCamera::CameraType,
PMCameraTypeProperty );
PMViewStructure* PMCamera::s_pDefaultViewStructure = 0;
PMMetaObject* PMCamera::s_pMetaObject = 0;
PMObject* createNewCamera( PMPart* part )
{
return new PMCamera( part );
}
const PMVector locationDefault = PMVector( 0.0, 0.0, 0.0 );
const PMVector lookAtDefault = PMVector( 0.0, 0.0, 1.0 );
const PMVector directionDefault = PMVector( 0.0, 0.0, 1.0 );
const PMVector upDefault = PMVector( 0.0, 1.0, 0.0 );
const PMVector rightDefault = PMVector( 4.0/3.0, 0.0, 0.0 );
const PMVector skyDefault = PMVector( 0.0, 1.0, 0.0 );
//const double aspectDefault = 1.0;
const bool angleEnabledDefault = false;
const double angleDefault = 90.0;
const PMCamera::CameraType cameraTypeDefault = PMCamera::Perspective;
const int cylinderTypeDefault = 1;
const bool focalBlurDefault = false;
const double apertureDefault = 0.4;
const int blurSamplesDefault = 10;
const PMVector focalPointDefault = PMVector( 0.0, 0.0, 0.0 );
const double confidenceDefault = 0.9;
const double varianceDefault = 0.008;
const bool c_defaultExport = true;
PMCamera::PMCamera( PMPart* part )
: Base( part )
{
m_location = locationDefault;
m_lookAt = lookAtDefault;
m_direction = directionDefault;
m_up = upDefault;
m_right = rightDefault;
m_sky = skyDefault;
m_angle = angleDefault;
m_angleEnabled = angleEnabledDefault;
m_cameraType = cameraTypeDefault;
m_cylinderType = cylinderTypeDefault;
m_focalBlurEnabled = focalBlurDefault;
m_aperture = apertureDefault;
m_blurSamples = blurSamplesDefault;
m_focalPoint = focalPointDefault;
m_confidence = confidenceDefault;
m_variance = varianceDefault;
m_export = c_defaultExport;
}
PMCamera::PMCamera( const PMCamera& c )
: Base( c )
{
m_location = c.m_location;
m_lookAt = c.m_lookAt;
m_direction = c.m_direction;
m_up = c.m_up;
m_right = c.m_right;
m_sky = c.m_sky;
m_angle = c.m_angle;
m_angleEnabled = c.m_angleEnabled;
m_cameraType = c.m_cameraType;
m_cylinderType = c.m_cylinderType;
m_focalBlurEnabled = c.m_focalBlurEnabled;
m_aperture = c.m_aperture;
m_blurSamples = c.m_blurSamples;
m_focalPoint = c.m_focalPoint;
m_confidence = c.m_confidence;
m_variance = c.m_variance;
m_export = c.m_export;
}
PMCamera::~PMCamera( )
{
}
TQString PMCamera::description( ) const
{
return i18n( "camera" );
}
void PMCamera::serialize( TQDomElement& e, TQDomDocument& doc ) const
{
e.setAttribute( "camera_type", cameraTypeToString( m_cameraType ) );
e.setAttribute( "cylinder_type", m_cylinderType );
e.setAttribute( "location", m_location.serializeXML( ) );
e.setAttribute( "sky", m_sky.serializeXML( ) );
e.setAttribute( "direction", m_direction.serializeXML( ) );
e.setAttribute( "right", m_right.serializeXML( ) );
e.setAttribute( "up", m_up.serializeXML( ) );
e.setAttribute( "look_at", m_lookAt.serializeXML( ) );
e.setAttribute( "angle_enabled", m_angleEnabled );
e.setAttribute( "angle", m_angle );
e.setAttribute( "focal_blur", m_focalBlurEnabled );
e.setAttribute( "aperture", m_aperture );
e.setAttribute( "blur_samples", m_blurSamples );
e.setAttribute( "focal_point", m_focalPoint.serializeXML( ) );
e.setAttribute( "confidence", m_confidence );
e.setAttribute( "variance", m_variance );
e.setAttribute( "export", m_export );
Base::serialize( e, doc );
}
void PMCamera::readAttributes( const PMXMLHelper& h )
{
m_cameraType = stringToCameraType( h.stringAttribute( "camera_type",
"perspective" ) );
m_cylinderType = h.intAttribute( "cylinder_type", cylinderTypeDefault );
m_location = h.vectorAttribute( "location", locationDefault );
m_sky = h.vectorAttribute( "sky", skyDefault );
m_direction = h.vectorAttribute( "direction", directionDefault );
m_right = h.vectorAttribute( "right", rightDefault );
m_up = h.vectorAttribute( "up", upDefault );
m_lookAt = h.vectorAttribute( "look_at", lookAtDefault );
m_angleEnabled = h.boolAttribute( "angle_enabled", angleEnabledDefault );
m_angle = h.doubleAttribute( "angle", angleDefault );
m_focalBlurEnabled = h.boolAttribute( "focal_blur", focalBlurDefault );
m_aperture = h.doubleAttribute( "aperture", apertureDefault );
m_blurSamples = h.intAttribute( "blur_samples", blurSamplesDefault );
m_focalPoint = h.vectorAttribute( "focal_point", focalPointDefault );
m_confidence = h.doubleAttribute( "confidence", confidenceDefault );
m_variance = h.doubleAttribute( "variance", varianceDefault );
m_export = h.boolAttribute( "export", c_defaultExport );
Base::readAttributes( h );
}
PMMetaObject* PMCamera::tqmetaObject( ) const
{
if( !s_pMetaObject )
{
s_pMetaObject = new PMMetaObject( "Camera", Base::tqmetaObject( ),
createNewCamera );
s_pMetaObject->addProperty(
new PMCameraProperty( "location", &PMCamera::setLocation,
&PMCamera::location ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "lookAt", &PMCamera::setLookAt,
&PMCamera::lookAt ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "up", &PMCamera::setUp,
&PMCamera::up ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "right", &PMCamera::setRight,
&PMCamera::right ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "direction", &PMCamera::setDirection,
&PMCamera::direction ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "sky", &PMCamera::setSky,
&PMCamera::sky ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "aspect", 0, &PMCamera::aspect ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "angleEnabled", &PMCamera::enableAngle,
&PMCamera::isAngleEnabled ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "angle", &PMCamera::setAngle,
&PMCamera::angle ) );
PMCameraTypeProperty* p = new PMCameraTypeProperty(
"cameraType", &PMCamera::setCameraType,
&PMCamera::cameraType );
p->addEnumValue( "Perspective", Perspective );
p->addEnumValue( "Orthographic", Orthographic );
p->addEnumValue( "FishEye", FishEye );
p->addEnumValue( "UltraWideAngle", UltraWideAngle );
p->addEnumValue( "Omnimax", Omnimax );
p->addEnumValue( "Panoramic", Panoramic );
p->addEnumValue( "Cylinder", Cylinder );
s_pMetaObject->addProperty( p );
s_pMetaObject->addProperty(
new PMCameraProperty( "cylinderType", &PMCamera::setCylinderType,
&PMCamera::cylinderType ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "focalBlurEnabled", &PMCamera::enableFocalBlur,
&PMCamera::isFocalBlurEnabled ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "aperture", &PMCamera::setAperture,
&PMCamera::aperture ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "blurSamples", &PMCamera::setBlurSamples,
&PMCamera::blurSamples ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "focalPoint", &PMCamera::setFocalPoint,
&PMCamera::focalPoint ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "confidence", &PMCamera::setConfidence,
&PMCamera::confidence ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "variance", &PMCamera::setVariance,
&PMCamera::variance ) );
s_pMetaObject->addProperty(
new PMCameraProperty( "export", &PMCamera::setExportPovray,
&PMCamera::exportPovray ) );
}
return s_pMetaObject;
}
void PMCamera::setLocation( const PMVector& p )
{
if( p != m_location )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMLocationID, m_location );
m_location = p;
m_location.resize( 3 );
setViewStructureChanged( );
}
}
void PMCamera::setLookAt( const PMVector& p )
{
if( p != m_lookAt )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMLookAtID, m_lookAt );
m_lookAt = p;
m_lookAt.resize( 3 );
setViewStructureChanged( );
}
}
void PMCamera::setUp( const PMVector& v )
{
if( v != m_up )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMUpID, m_up );
m_up = v;
m_up.resize( 3 );
setViewStructureChanged( );
}
}
void PMCamera::setRight( const PMVector& v )
{
if( v != m_right )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMRightID, m_right );
m_right = v;
m_right.resize( 3 );
setViewStructureChanged( );
}
}
void PMCamera::setDirection( const PMVector& v )
{
if( v != m_direction )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMDirectionID, m_direction );
m_direction = v;
m_direction.resize( 3 );
setViewStructureChanged( );
}
}
void PMCamera::setSky( const PMVector& v )
{
if( v != m_sky )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMSkyID, m_sky );
m_sky = v;
m_sky.resize( 3 );
setViewStructureChanged( );
}
}
double PMCamera::aspect( ) const
{
double d = m_up.abs( );
if( approxZero( d ) )
return 1.0;
return m_right.abs( ) / d;
}
void PMCamera::enableAngle( bool yes )
{
if( yes != m_angleEnabled )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMAngleEnabledID, m_angleEnabled );
m_angleEnabled = yes;
setViewStructureChanged( );
}
}
void PMCamera::setAngle( double a )
{
if( a != m_angle )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMAngleID, m_angle );
m_angle = a;
setViewStructureChanged( );
}
}
void PMCamera::setCameraType( PMCamera::CameraType t )
{
if( t != m_cameraType )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMCameraTypeID, m_cameraType );
m_cameraType = t;
setViewStructureChanged( );
}
}
void PMCamera::setCylinderType( int t )
{
if( ( t < 1 ) || ( t > 4 ) )
kdError( PMArea ) << "Invalid type in PMCylinder::setCylinderType\n";
else if( t != m_cylinderType )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMCylinderTypeID, m_cylinderType );
m_cylinderType = t;
setViewStructureChanged( );
}
}
void PMCamera::enableFocalBlur( bool yes )
{
if( yes != m_focalBlurEnabled )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMFocalBlurID, m_focalBlurEnabled );
m_focalBlurEnabled = yes;
}
}
void PMCamera::setAperture( double a )
{
if( a < 0 )
kdError( PMArea ) << "Aperture < 0 in PMCylinder::setAperture\n";
else if( a != m_aperture )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMApertureID, m_aperture );
m_aperture = a;
}
}
void PMCamera::setBlurSamples( int s )
{
if( s < 0 )
kdError( PMArea ) << "Samples < 0 in PMCylinder::setBlutSamples\n";
else if( s != m_blurSamples )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMBlurSamplesID, m_blurSamples );
m_blurSamples = s;
}
}
void PMCamera::setFocalPoint( const PMVector& v )
{
if( v != m_focalPoint )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMFocalPointID, m_focalPoint );
m_focalPoint = v;
}
}
void PMCamera::setConfidence( double c )
{
if( ( c < 0.0 ) || ( c > 1.0 ) )
kdError( PMArea ) << "Confidence not in [0.0 1.0] in PMCylinder::setConfidence\n";
else if( c != m_confidence )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMConfidenceID, m_confidence );
m_confidence = c;
}
}
void PMCamera::setVariance( double v )
{
if( v < 0 )
kdError( PMArea ) << "Variance < 0 in PMCylinder::setVariance\n";
else if( v != m_variance )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMVarianceID, m_variance );
m_variance = v;
}
}
void PMCamera::setExportPovray( bool ex )
{
if( m_export != ex )
{
if( m_pMemento )
m_pMemento->addData( s_pMetaObject, PMExportID, m_export );
m_export = ex;
}
}
PMDialogEditBase* PMCamera::editWidget( TQWidget* tqparent ) const
{
return new PMCameraEdit( tqparent );
}
void PMCamera::restoreMemento( PMMemento* s )
{
PMMementoDataIterator it( s );
PMMementoData* data;
for( ; it.current( ); ++it )
{
data = it.current( );
if( data->objectType( ) == s_pMetaObject )
{
switch( data->valueID( ) )
{
case PMLocationID:
setLocation( data->vectorData( ) );
break;
case PMLookAtID:
setLookAt( data->vectorData( ) );
break;
case PMUpID:
setUp( data->vectorData( ) );
break;
case PMRightID:
setRight( data->vectorData( ) );
break;
case PMDirectionID:
setDirection( data->vectorData( ) );
break;
case PMSkyID:
setSky( data->vectorData( ) );
break;
case PMAngleEnabledID:
enableAngle( data->boolData( ) );
break;
case PMAngleID:
setAngle( data->doubleData( ) );
break;
case PMCameraTypeID:
setCameraType( ( CameraType ) data->intData( ) );
break;
case PMCylinderTypeID:
setCylinderType( data->intData( ) );
break;
case PMFocalBlurID:
enableFocalBlur( data->boolData( ) );
break;
case PMBlurSamplesID:
setBlurSamples( data->intData( ) );
break;
case PMFocalPointID:
setFocalPoint( data->vectorData( ) );
break;
case PMConfidenceID:
setConfidence( data->doubleData( ) );
break;
case PMVarianceID:
setVariance( data->doubleData( ) );
break;
case PMApertureID:
setAperture( data->doubleData( ) );
break;
case PMExportID:
setExportPovray( data->boolData( ) );
break;
default:
kdError( PMArea ) << "Wrong ID in PMCamera::restoreMemento\n";
break;
}
}
}
Base::restoreMemento( s );
}
void PMCamera::createViewStructure( )
{
PMVector newUp, newRight, newDirection, tmp;
double upLen, rightLen;
if( !m_pViewStructure )
{
m_pViewStructure = new PMViewStructure( defaultViewStructure( ) );
m_pViewStructure->points( ).detach( );
}
PMPointArray& points = m_pViewStructure->points( );
calculateLookAtAngle( newRight, newUp, newDirection );
points[0] = m_lookAt;
points[1] = m_location;
upLen = newUp.abs( );
rightLen = newRight.abs( );
if( rightLen > upLen )
{
newUp /= rightLen;
newRight /= rightLen;
newDirection /= rightLen;
}
else
{
newUp /= upLen;
newRight /= upLen;
newDirection /= upLen;
}
newRight /= 2.0;
newUp /= 2.0;
tmp = m_location + newDirection;
points[2] = tmp - newRight + newUp;
points[3] = tmp - newRight - newUp;
points[4] = tmp + newRight - newUp;
points[5] = tmp + newRight + newUp;
// points[6] = m_location + m_sky;
}
PMViewStructure* PMCamera::defaultViewStructure( ) const
{
if( !s_pDefaultViewStructure )
{
s_pDefaultViewStructure = new PMViewStructure( 6, 9 );
PMLineArray& lines = s_pDefaultViewStructure->lines( );
lines[0] = PMLine( 0, 1 );
lines[1] = PMLine( 1, 2 );
lines[2] = PMLine( 1, 3 );
lines[3] = PMLine( 1, 4 );
lines[4] = PMLine( 1, 5 );
lines[5] = PMLine( 2, 3 );
lines[6] = PMLine( 2, 5 );
lines[7] = PMLine( 3, 4 );
lines[8] = PMLine( 4, 5 );
// lines[9] = PMLine( 1, 6 );
}
return s_pDefaultViewStructure;
}
void PMCamera::controlPoints( PMControlPointList& list )
{
PMControlPoint* p;
p = new PM3DControlPoint( m_location, PMLocationID, i18n( "Location" ) );
list.append( p );
list.append( new PM3DControlPoint( m_lookAt, PMLookAtID, i18n( "Look at" ) ) );
}
void PMCamera::controlPointsChanged( PMControlPointList& list )
{
PMControlPoint* p;
for( p = list.first( ); p; p = list.next( ) )
{
if( p->changed( ) )
{
switch( p->id( ) )
{
case PMLocationID:
setLocation( ( ( PM3DControlPoint* ) p )->point( ) );
break;
case PMLookAtID:
setLookAt( ( ( PM3DControlPoint* ) p )->point( ) );
break;
default:
kdError( PMArea ) << "Wrong ID in PMCamera::controlPointsChanged\n";
break;
}
}
}
}
void PMCamera::calculateLookAtAngle( PMVector& right, PMVector& up, PMVector& direction )
{
PMVector tmpVector;
double directionLen, upLen, rightLen, handedness, angle;
angle = m_angle;
if( m_cameraType == Perspective )
{
if( angle < 0.0 )
angle = angleDefault;
if( angle >= 180.0 )
angle = angleDefault;
}
else
angle = 90.0;
directionLen = m_direction.abs( );
upLen = m_up.abs( );
rightLen = m_right.abs( );
// for safety: if vector is null vector, use the default one
if( approxZero( directionLen ) )
{
direction = directionDefault;
directionLen = direction.abs( );
}
else
direction = m_direction;
if( approxZero( upLen ) )
{
up = upDefault;
upLen = up.abs( );
}
else
up = m_up;
if( approxZero( rightLen ) )
{
right = rightDefault;
rightLen = right.abs( );
}
else
right = m_right;
if( m_angleEnabled )
{
// calculate angle
direction /= directionLen;
directionLen = 0.5 * rightLen / tan( angle * M_PI / 360.0 );
direction *= directionLen;
}
// calculate handedness
tmpVector = PMVector::cross( up, direction );
handedness = PMVector::dot( tmpVector, right );
direction = m_lookAt - m_location;
if( approxZero( direction.abs( ) ) )
{
// Camera location and look_at point are the same
direction = directionDefault;
}
// normalize new direction
direction /= direction.abs( );
tmpVector = right;
right = PMVector::cross( m_sky, direction );
if( approxZero( right.abs( ) ) )
right = tmpVector;
right /= right.abs( );
up = PMVector::cross( direction, right );
direction *= directionLen;
if( handedness > 0.0 )
right *= rightLen;
else
right *= -rightLen;
up *= upLen;
}
TQString PMCamera::cameraTypeToString( PMCamera::CameraType t )
{
TQString str( "perspective" );
switch( t )
{
case Perspective:
break;
case Orthographic:
str = "orthographic";
break;
case FishEye:
str = "fisheye";
break;
case UltraWideAngle:
str = "ultra_wide_angle";
break;
case Omnimax:
str = "omnimax";
break;
case Panoramic:
str = "panoramic";
break;
case Cylinder:
str = "cylinder";
break;
}
return str;
}
PMCamera::CameraType PMCamera::stringToCameraType( const TQString& str )
{
CameraType t = Perspective;
if( str == "perspective" )
t = Perspective;
else if( str == "orthographic" )
t = Orthographic;
else if( str == "fisheye" )
t = FishEye;
else if( str == "ultra_wide_angle" )
t = UltraWideAngle;
else if( str == "omnimax" )
t = Omnimax;
else if( str == "panoramic" )
t = Panoramic;
else if( str == "cylinder" )
t = Cylinder;
else
kdDebug( PMArea ) << "Unknown camera type\n";
return t;
}
void PMCamera::cleanUp( ) const
{
if( s_pDefaultViewStructure )
{
delete s_pDefaultViewStructure;
s_pDefaultViewStructure = 0;
}
if( s_pMetaObject )
{
delete s_pMetaObject;
s_pMetaObject = 0;
}
Base::cleanUp( );
}