Archon: archon/x3d/server/interpolation.C Source File

00001 /*
00002  * This file is part of the "Archon" framework.
00003  * (http://files3d.sourceforge.net)
00004  *
00005  * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
00006  *
00007  * Permission to use, copy, modify, and distribute this software and
00008  * its documentation under the terms of the GNU General Public License is
00009  * hereby granted. No representations are made about the suitability of
00010  * this software for any purpose. It is provided "as is" without express
00011  * or implied warranty. See the GNU General Public License
00012  * (http://www.gnu.org/copyleft/gpl.html) for more details.
00013  *
00014  * The characters in this file are ISO8859-1 encoded.
00015  *
00016  * The documentation in this file is in "Doxygen" style
00017  * (http://www.doxygen.org).
00018  */
00019 
00026 #include <archon/util/color.H>
00027 
00028 #include <archon/x3d/server/field_type.H>
00029 #include <archon/x3d/server/field.H>
00030 #include <archon/x3d/server/interpolation.H>
00031 
00032 namespace Archon
00033 {
00034   namespace X3D
00035   {
00036     const NodeType *InterpolatorNode::type = 0;
00037     const NodeType *ColorInterpolator::type = 0;
00038     const NodeType *CoordinateInterpolator::type = 0;
00039     const NodeType *CoordinateInterpolator2D::type = 0;
00040     const NodeType *NormalInterpolator::type = 0;
00041     const NodeType *OrientationInterpolator::type = 0;
00042     const NodeType *PositionInterpolator::type = 0;
00043     const NodeType *PositionInterpolator2D::type = 0;
00044     const NodeType *ScalarInterpolator::type = 0;
00045 
00046     void initializeInterpolationComponent()
00047     {
00048       vector<const FieldBase *> fields;
00049 
00050 
00051       // InterpolatorNode
00052 
00053       fields.push_back(newEventIn("set_fraction", SFFloat::type,
00054                                   &InterpolatorNode::fractionAssign,
00055                                   &InterpolatorNode::fractionStamp));
00056       fields.push_back(newExposedField("key", MFFloat::type,
00057                                        &InterpolatorNode::key,
00058                                        &InterpolatorNode::keyChanged,
00059                                        &InterpolatorNode::keyStamp));
00060       InterpolatorNode::type =
00061         NodeType::newAbstract("InterpolatorNode", false, &fields,
00062                               ChildNode::type);
00063       fields.clear();
00064 
00065 
00066       // ColorInterpolator
00067 
00068       fields.push_back(newExposedField("keyValue", MFColor::type,
00069                                        &ColorInterpolator::keyValue,
00070                                        &ColorInterpolator::keyValueChanged,
00071                                        &ColorInterpolator::keyValueStamp));
00072       fields.push_back(newEventOut("value_changed", SFColor::type,
00073                                    &ColorInterpolator::value,
00074                                    &ColorInterpolator::valueChanged));
00075       ColorInterpolator::type =
00076         NodeType::newConcrete("ColorInterpolator", "children",
00077                               ColorInterpolator::instantiate, &fields,
00078                               InterpolatorNode::type);
00079       fields.clear();
00080 
00081 
00082       // CoordinateInterpolator
00083 
00084       fields.push_back(newExposedField("keyValue", MFVec3f::type,
00085                                        &CoordinateInterpolator::keyValue,
00086                                        &CoordinateInterpolator::keyValueChanged,
00087                                        &CoordinateInterpolator::keyValueStamp));
00088       fields.push_back(newEventOut("value_changed", MFVec3f::type,
00089                                    &CoordinateInterpolator::value,
00090                                    &CoordinateInterpolator::valueChanged));
00091       CoordinateInterpolator::type =
00092         NodeType::newConcrete("CoordinateInterpolator", "children",
00093                               CoordinateInterpolator::instantiate, &fields,
00094                               InterpolatorNode::type);
00095       fields.clear();
00096 
00097 
00098       // CoordinateInterpolator2D
00099 
00100       fields.push_back(newExposedField("keyValue", MFVec2f::type,
00101                                        &CoordinateInterpolator2D::keyValue,
00102                                        &CoordinateInterpolator2D::keyValueChanged,
00103                                        &CoordinateInterpolator2D::keyValueStamp));
00104       fields.push_back(newEventOut("value_changed", MFVec2f::type,
00105                                    &CoordinateInterpolator2D::value,
00106                                    &CoordinateInterpolator2D::valueChanged));
00107       CoordinateInterpolator2D::type =
00108         NodeType::newConcrete("CoordinateInterpolator2D", "children",
00109                               CoordinateInterpolator2D::instantiate, &fields,
00110                               InterpolatorNode::type);
00111       fields.clear();
00112 
00113 
00114       // NormalInterpolator
00115 
00116       fields.push_back(newExposedField("keyValue", MFVec3f::type,
00117                                        &NormalInterpolator::keyValue,
00118                                        &NormalInterpolator::keyValueChanged,
00119                                        &NormalInterpolator::keyValueStamp));
00120       fields.push_back(newEventOut("value_changed", MFVec3f::type,
00121                                    &NormalInterpolator::value,
00122                                    &NormalInterpolator::valueChanged));
00123       NormalInterpolator::type =
00124         NodeType::newConcrete("NormalInterpolator", "children",
00125                               NormalInterpolator::instantiate, &fields,
00126                               InterpolatorNode::type);
00127       fields.clear();
00128 
00129 
00130       // OrientationInterpolator
00131 
00132       fields.push_back(newExposedField("keyValue", MFRotation::type,
00133                                        &OrientationInterpolator::keyValue,
00134                                        &OrientationInterpolator::keyValueChanged,
00135                                        &OrientationInterpolator::keyValueStamp));
00136       fields.push_back(newEventOut("value_changed", SFRotation::type,
00137                                    &OrientationInterpolator::value,
00138                                    &OrientationInterpolator::valueChanged));
00139       OrientationInterpolator::type =
00140         NodeType::newConcrete("OrientationInterpolator", "children",
00141                               OrientationInterpolator::instantiate, &fields,
00142                               InterpolatorNode::type);
00143       fields.clear();
00144 
00145 
00146       // PositionInterpolator
00147 
00148       fields.push_back(newExposedField("keyValue", MFVec3f::type,
00149                                        &PositionInterpolator::keyValue,
00150                                        &PositionInterpolator::keyValueChanged,
00151                                        &PositionInterpolator::keyValueStamp));
00152       fields.push_back(newEventOut("value_changed", SFVec3f::type,
00153                                    &PositionInterpolator::value,
00154                                    &PositionInterpolator::valueChanged));
00155       PositionInterpolator::type =
00156         NodeType::newConcrete("PositionInterpolator", "children",
00157                               PositionInterpolator::instantiate, &fields,
00158                               InterpolatorNode::type);
00159       fields.clear();
00160 
00161 
00162       // PositionInterpolator2D
00163 
00164       fields.push_back(newExposedField("keyValue", MFVec2f::type,
00165                                        &PositionInterpolator2D::keyValue,
00166                                        &PositionInterpolator2D::keyValueChanged,
00167                                        &PositionInterpolator2D::keyValueStamp));
00168       fields.push_back(newEventOut("value_changed", SFVec2f::type,
00169                                    &PositionInterpolator2D::value,
00170                                    &PositionInterpolator2D::valueChanged));
00171       PositionInterpolator2D::type =
00172         NodeType::newConcrete("PositionInterpolator2D", "children",
00173                               PositionInterpolator2D::instantiate, &fields,
00174                               InterpolatorNode::type);
00175       fields.clear();
00176 
00177 
00178       // ScalarInterpolator
00179 
00180       fields.push_back(newExposedField("keyValue", MFFloat::type,
00181                                        &ScalarInterpolator::keyValue,
00182                                        &ScalarInterpolator::keyValueChanged,
00183                                        &ScalarInterpolator::keyValueStamp));
00184       fields.push_back(newEventOut("value_changed", SFFloat::type,
00185                                    &ScalarInterpolator::value,
00186                                    &ScalarInterpolator::valueChanged));
00187       ScalarInterpolator::type =
00188         NodeType::newConcrete("ScalarInterpolator", "children",
00189                               ScalarInterpolator::instantiate, &fields,
00190                               InterpolatorNode::type);
00191       fields.clear();
00192     }
00193 
00202     Vector3 normalInterp(double x, double x1, double x2, Vector3 y1, Vector3 y2)
00203     {
00204       y1.normalize();
00205       y2.normalize();
00206       double p = dot(y1, y2);
00207       if(p==1) return y1;
00208       Vector3 n = p==-1 ? Vector3(0, 0, 1) : y1 * y2;
00209       return
00210         linInterp(x, x1, x2,
00211                   Matrix3x3(Rotation3(n, linInterp(x, x1, x2, 0.0, acos(p))))(y1),
00212                   Matrix3x3(Rotation3(n, linInterp(x, x1, x2, -acos(p), 0.0)))(y2));
00213     }
00214 
00221     Rotation3 rotInterp(double x, double x1, double x2, Rotation3 y1, Rotation3 y2)
00222     {
00223       // Pick the shortest arc
00224       double d = y2.angle - y1.angle;
00225       if(d < -M_PI) y2.angle += 2*M_PI;
00226       else if(d > M_PI) y1.angle += 2*M_PI;
00227 
00228       return Rotation3(normalInterp(x, x1, x2, y1.axis, y2.axis), linInterp(x, x1, x2, y1.angle, y2.angle));
00229     }
00230 
00231     bool ColorInterpolator::fractionAssign(const double &f, const Time &t)
00232     {
00233       fractionStamp = t;
00234       unsigned i=0;
00235       unsigned n=min(key.size(), keyValue.size());
00236       while(i<n && key[i]<=f) ++i;
00237       value = i == n ?
00238         n ? keyValue[n-1] : Vector3::zero() :
00239         i ? Color::interp(f, key[i-1], key[i], keyValue[i-1], keyValue[i]) :
00240         keyValue[0];
00241       Event event(new SimpleValue<Vector3>(SFColor::type, value), fractionStamp);
00242       valueChanged.cascadeEvent(&event);
00243       return true;
00244     }
00245 
00246     bool CoordinateInterpolator::fractionAssign(const double &f, const Time &t)
00247     {
00248       fractionStamp = t;
00249       unsigned i=0;
00250       unsigned n=key.size();
00251       unsigned m=keyValue.size()/key.size();
00252       while(i<n && key[i]<=f) ++i;
00253       if(i==n)
00254       {
00255         if(n)
00256         {
00257           vector<Vector3>::iterator j = keyValue.begin() + n*m;
00258           value.assign(j-m, j);
00259         }
00260         else value.clear();
00261       }
00262       else
00263       {
00264         if(i)
00265         {
00266           value.resize(m);
00267           vector<Vector3>::iterator j = keyValue.begin() + i*m;
00268           for(unsigned k=0; k<m; ++j, ++k)
00269             value[k] = linInterp(f, key[i-1], key[i], *(j-m), *j);
00270         }
00271         else
00272         {
00273           vector<Vector3>::iterator j = keyValue.begin();
00274           value.assign(j, j+m);
00275         }
00276       }
00277       Event event(new SimpleValue<vector<Vector3> >(MFVec3f::type, value), fractionStamp);
00278       valueChanged.cascadeEvent(&event);
00279       return true;
00280     }
00281 
00282     bool CoordinateInterpolator2D::fractionAssign(const double &f, const Time &t)
00283     {
00284       fractionStamp = t;
00285       unsigned i=0;
00286       unsigned n=key.size();
00287       unsigned m=keyValue.size()/key.size();
00288       while(i<n && key[i]<=f) ++i;
00289       if(i==n)
00290       {
00291         if(n)
00292         {
00293           vector<Vector2>::iterator j = keyValue.begin() + n*m;
00294           value.assign(j-m, j);
00295         }
00296         else value.clear();
00297       }
00298       else
00299       {
00300         if(i)
00301         {
00302           value.resize(m);
00303           vector<Vector2>::iterator j = keyValue.begin() + i*m;
00304           for(unsigned k=0; k<m; ++j, ++k)
00305             value[k] = linInterp(f, key[i-1], key[i], *(j-m), *j);
00306         }
00307         else
00308         {
00309           vector<Vector2>::iterator j = keyValue.begin();
00310           value.assign(j, j+m);
00311         }
00312       }
00313       Event event(new SimpleValue<vector<Vector2> >(MFVec2f::type, value), fractionStamp);
00314       valueChanged.cascadeEvent(&event);
00315       return true;
00316     }
00317 
00318     bool NormalInterpolator::fractionAssign(const double &f, const Time &t)
00319     {
00320       fractionStamp = t;
00321       unsigned i=0;
00322       unsigned n=key.size();
00323       unsigned m=keyValue.size()/key.size();
00324       while(i<n && key[i]<=f) ++i;
00325       if(i==n)
00326       {
00327         if(n)
00328         {
00329           vector<Vector3>::iterator j = keyValue.begin() + n*m;
00330           value.assign(j-m, j);
00331         }
00332         else value.clear();
00333       }
00334       else
00335       {
00336         if(i)
00337         {
00338           value.resize(m);
00339           vector<Vector3>::iterator j = keyValue.begin() + i*m;
00340           for(unsigned k=0; k<m; ++j, ++k)
00341             value[k] = normalInterp(f, key[i-1], key[i], *(j-m), *j);
00342         }
00343         else
00344         {
00345           vector<Vector3>::iterator j = keyValue.begin();
00346           value.assign(j, j+m);
00347         }
00348       }
00349       Event event(new SimpleValue<vector<Vector3> >(MFVec3f::type, value), fractionStamp);
00350       valueChanged.cascadeEvent(&event);
00351       return true;
00352     }
00353 
00354     bool OrientationInterpolator::fractionAssign(const double &f, const Time &t)
00355     {
00356       fractionStamp = t;
00357       unsigned i=0;
00358       unsigned n=min(key.size(), keyValue.size());
00359       while(i<n && key[i]<=f) ++i;
00360       value = i == n ?
00361         n ? keyValue[n-1] : Rotation3(Vector3(0, 0, 1), 0) :
00362         i ? rotInterp(f, key[i-1], key[i], keyValue[i-1], keyValue[i]) :
00363         keyValue[0];
00364       Event event(new SimpleValue<Rotation3>(SFRotation::type, value), fractionStamp);
00365       valueChanged.cascadeEvent(&event);
00366       return true;
00367     }
00368 
00369     bool PositionInterpolator::fractionAssign(const double &f, const Time &t)
00370     {
00371       fractionStamp = t;
00372       unsigned i=0;
00373       unsigned n=min(key.size(), keyValue.size());
00374       while(i<n && key[i]<=f) ++i;
00375       value = i == n ?
00376         n ? keyValue[n-1] : Vector3::zero() :
00377         i ? linInterp(f, key[i-1], key[i], keyValue[i-1], keyValue[i]) :
00378         keyValue[0];
00379       Event event(new SimpleValue<Vector3>(SFVec3f::type, value), fractionStamp);
00380       valueChanged.cascadeEvent(&event);
00381       return true;
00382     }
00383 
00384     bool PositionInterpolator2D::fractionAssign(const double &f, const Time &t)
00385     {
00386       fractionStamp = t;
00387       unsigned i=0;
00388       unsigned n=min(key.size(), keyValue.size());
00389       while(i<n && key[i]<=f) ++i;
00390       value = i == n ?
00391         n ? keyValue[n-1] : Vector2::zero() :
00392         i ? linInterp(f, key[i-1], key[i], keyValue[i-1], keyValue[i]) :
00393         keyValue[0];
00394       Event event(new SimpleValue<Vector2>(SFVec2f::type, value), fractionStamp);
00395       valueChanged.cascadeEvent(&event);
00396       return true;
00397     }
00398 
00399     bool ScalarInterpolator::fractionAssign(const double &f, const Time &t)
00400     {
00401       fractionStamp = t;
00402       unsigned i=0;
00403       unsigned n=min(key.size(), keyValue.size());
00404       while(i<n && key[i]<=f) ++i;
00405       value = i == n ?
00406         n ? keyValue[n-1] : 0 :
00407         i ? linInterp(f, key[i-1], key[i], keyValue[i-1], keyValue[i]) :
00408         keyValue[0];
00409       Event event(new SimpleValue<double>(SFFloat::type, value), fractionStamp);
00410       valueChanged.cascadeEvent(&event);
00411       return true;
00412     }
00413   }
00414 }