const bool complete) const
# else
bool homographyEstimatorBase::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && transformEstimator::parameters::write(handler,false);
# else
bool (transformEstimator::parameters::* p_writeMS)(ioHandler&,const bool) const =
transformEstimator::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
const bool complete) const
# else
bool shClassifier::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
b=b && lti::write(handler, "numberOfBins",numberOfBins);
b=b && lti::write(handler, "binVector",binVector);
b=b && lti::write(handler, "minimum",minimum);
b=b && lti::write(handler, "maximum",maximum);
b=b && lti::write(handler, "autoBounds", autoBounds);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && supervisedInstanceClassifier::parameters::write(handler,false);
# else
bool (supervisedInstanceClassifier::parameters::* p_writeMS)(ioHandler&,const bool) const =
supervisedInstanceClassifier::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
const bool complete) const
# else
bool ioFunctor::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
lti::write(handler,"filename",filename);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && functor::parameters::write(handler,false);
# else
bool (functor::parameters::* p_writeMS)(ioHandler&,const bool) const =
functor::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
bool labelAdjacencyMap::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"minColors",minColors);
lti::read(handler,"thePalette",thePalette);
lti::read(handler,"neighborhood",neighborhood);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && functor::parameters::read(handler,false);
# else
bool (functor::parameters::* p_readMS)(ioHandler&,const bool) =
functor::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool homography8DofEstimator::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && homographyEstimatorBase::parameters::read(handler,false);
# else
bool (homographyEstimatorBase::parameters::* p_readMS)
(ioHandler&,const bool)=
homographyEstimatorBase::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool SOFM2D::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"area",area);
lti::read(handler,"sizeX",sizeX);
lti::read(handler,"sizeY",sizeY);
lti::read(handler,"calculateSize",calculateSize);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && SOFM::parameters::read(handler,false);
# else
bool (SOFM::parameters::* p_readMS)(ioHandler&,const bool) =
SOFM::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
const bool complete) const
# else
bool sffs::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
usedCostFunction->write(handler,false);
// lti::write(handler,"classifier",classifier->getTypeName());
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && featureSelector::parameters::write(handler,false);
# else
bool (featureSelector::parameters::* p_writeMS)(ioHandler&,const bool) const =
featureSelector::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
const bool complete) const
# else
bool distanceTransform::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
switch(distance) {
case EightNeighborhood:
lti::write(handler, "distance","EightNeighborhood");
break;
case FourNeighborhood:
lti::write(handler, "distance","FourNeighborhood");
break;
case EuclideanSqr:
lti::write(handler, "distance","EuclideanSqr");
break;
case Euclidean:
lti::write(handler, "distance","Euclidean");
break;
case EightSED:
lti::write(handler,"distance","EightSED");
break;
case EightSEDSqr:
lti::write(handler,"distance","EightSEDSqr");
break;
case FourSED:
lti::write(handler,"distance","FourSED");
break;
case FourSEDSqr:
lti::write(handler,"distance","FourSEDSqr");
break;
default:
lti::write(handler, "distance","EightNeighborhood");
break;
}
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && morphology::parameters::write(handler,false);
# else
bool (morphology::parameters::* p_writeMS)(ioHandler&,const bool) const =
morphology::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
bool histogramRGBL::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"smooth",smooth);
lti::read(handler,"normalize",normalize);
lti::read(handler,"cells",cells);
lti::read(handler,"considerAllData",considerAllData);
lti::read(handler,"ignoreValue",ignoreValue);
lti::read(handler,"kernel",kernel);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && globalFeatureExtractor::parameters::read(handler,false);
# else
bool (globalFeatureExtractor::parameters::* p_readMS)(ioHandler&,const bool) =
globalFeatureExtractor::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool sigmoidKernel::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
b=b && lti::read(handler, "kappa", kappa);
b=b && lti::read(handler, "theta", theta);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && kernelFunctor<double>::parameters::read(handler,false);
# else
bool (kernelFunctor<double>::parameters::* p_readMS)(ioHandler&,const bool) =
kernelFunctor<double>::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool kNearestNeighFilter::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"kernelSize",kernelSize);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && filter::parameters::read(handler,false);
# else
bool (filter::parameters::* p_readMS)(ioHandler&,const bool) =
filter::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool fastViewer::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler, "topleft" ,topleft);
lti::read(handler, "noBorder" ,noBorder);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && viewerBase::parameters::read(handler,false);
# else
bool (viewerBase::parameters::* p_readMS)(ioHandler&,const bool) =
viewerBase::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool medianCut::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"preQuant",preQuant);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && colorQuantization::parameters::read(handler,false);
# else
bool (colorQuantization::parameters::* p_readMS)(ioHandler&,const bool) =
colorQuantization::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool regionMerge::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"threshold",threshold);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && functor::parameters::read(handler,false);
# else
bool (functor::parameters::* p_readMS)(ioHandler&,const bool) =
functor::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool huMoments::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"scaling",scaling);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && globalFeatureExtractor::parameters::read(handler,false);
# else
bool (globalFeatureExtractor::parameters::* p_readMS)(ioHandler&,const bool) =
globalFeatureExtractor::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool binomialDistribution::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
lti::read(handler,"sampleSize",sampleSize);
lti::read(handler,"events",events);
lti::read(handler,"confidence",confidence);
lti::read(handler,"accuracy",accuracy);
lti::read(handler,"baseProbability",baseProbability);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && discreteRandomDistribution::parameters::read(handler,false);
# else
bool (discreteRandomDistribution::parameters::* p_readMS)(ioHandler&,const bool) =
discreteRandomDistribution::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
// read method
bool MLP::read(ioHandler& handler,const bool complete) {
bool b(true);
if (complete) {
b = handler.readBegin();
}
// read the standard data (output and parameters)
supervisedInstanceClassifier::read(handler,false);
if (b) {
if (lti::read(handler,"inputs",inputs) &&
lti::read(handler,"outputs",outputs)) {
if (lti::read(handler,"weights",weights)) {
b = initWeights(true); // initialize internal state keeping
// the weights...
} else {
initWeights(false,-1,1);
b = false;
}
} else {
b = false;
}
}
if (complete) {
b = b && handler.readEnd();
}
return b;
}
const bool complete) const
# else
bool MLP::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
switch(trainingMode) {
case SteepestDescent:
lti::write(handler,"trainingMode","SteepestDescent");
break;
case ConjugateGradients:
lti::write(handler,"trainingMode","ConjugateGradients");
break;
default:
lti::write(handler,"trainingMode","SteepestDescent");
};
lti::write(handler,"batchMode",batchMode);
lti::write(handler,"momentum",momentum);
lti::write(handler,"hiddenUnits",hiddenUnits);
lti::write(handler,"learnrate",learnrate);
lti::write(handler,"maxNumberOfEpochs",maxNumberOfEpochs);
lti::write(handler,"stopError",stopError);
className classNamer;
unsigned int i;
for (i=0;i<activationFunctions.size();++i) {
lti::write(handler,"activationFunctorType",
classNamer.get(*activationFunctions[i]));
lti::write(handler,"functor",*activationFunctions[i]);
}
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && supervisedInstanceClassifier::parameters::write(handler,false);
# else
bool (supervisedInstanceClassifier::parameters::* p_writeMS)(ioHandler&,const bool) const =
supervisedInstanceClassifier::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
bool MLP::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
std::string str;
lti::read(handler,"trainingMode",str);
if (str == "ConjugateGradients") {
trainingMode = ConjugateGradients;
} else {
trainingMode = SteepestDescent;
}
lti::read(handler,"batchMode",batchMode);
lti::read(handler,"momentum",momentum);
lti::read(handler,"hiddenUnits",hiddenUnits);
lti::read(handler,"learnrate",learnrate);
lti::read(handler,"maxNumberOfEpochs",maxNumberOfEpochs);
lti::read(handler,"stopError",stopError);
unsigned int i;
for (i=0;i<activationFunctions.size();++i) {
delete activationFunctions[i];
}
const int layers = hiddenUnits.size()+1;
activationFunctions.resize(layers);
std::string className;
for (i=0;i<activationFunctions.size();++i) {
lti::read(handler,"activationFunctorType",className);
activationFunctions[i] = objFactory.newInstance(className);
lti::read(handler,"functor",*activationFunctions[i]);
}
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && supervisedInstanceClassifier::parameters::read(handler,false);
# else
bool (supervisedInstanceClassifier::parameters::* p_readMS)(ioHandler&,const bool) =
supervisedInstanceClassifier::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool hessianFunctor::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
std::string str;
lti::read(handler,"kernelType",str);
if (str == "Ando") {
kernelType = Ando;
} else if (str == "OGD") {
kernelType = OGD2;
} else if (str == "Classic") {
kernelType = Classic;
} else if (str == "Sobel") {
kernelType = Sobel;
} else if (str == "Prewitt") {
kernelType = Prewitt;
} else if (str == "Robinson") {
kernelType = Robinson;
} else if (str == "Kirsch") {
kernelType = Kirsch;
} else if (str == "Harris") {
kernelType = Harris;
} else if (str == "Hessian") {
kernelType = Hessian;
} else {
kernelType = Hessian;
handler.setStatusString("Unknown kernel type");
b = false;
}
lti::read(handler,"kernelSize",kernelSize);
lti::read(handler,"kernelVariance",kernelVariance);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && transform::parameters::read(handler,false);
# else
bool (transform::parameters::* p_readMS)(ioHandler&,const bool) =
transform::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool dunnIndex::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
std::string str1,str2;
lti::read(handler,"diameterMeasure",str1);
lti::read(handler,"distanceMeasure",str2);
if (str1.find("tand") != std::string::npos) {
diameterMeasure = Standard;
} else if (str1.find("verag") != std::string::npos) {
diameterMeasure = Average;
} else if (str1.find("entr")!= std::string::npos) {
diameterMeasure = Centroid;
}
if (str2.find("inim") != std::string::npos) {
distanceMeasure = Minimum;
} else if (str2.find("axim") != std::string::npos) {
distanceMeasure = Maximum;
} else if (str2.find("ean") != std::string::npos) {
distanceMeasure = Mean;
} else if (str2.find("nterp") != std::string::npos) {
distanceMeasure = Interpoint;
} else if (str2.find("entroid") != std::string::npos) {
distanceMeasure = Centroids;
}
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && clusteringValidity::parameters::read(handler,false);
# else
bool (clusteringValidity::parameters::* p_readMS)(ioHandler&,const bool) =
clusteringValidity::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
bool distanceTransform::parameters::readMS(ioHandler& handler,
const bool complete)
# endif
{
bool b = true;
if (complete) {
b = handler.readBegin();
}
if (b) {
std::string str;
lti::read(handler,"distance",str);
if (str == "EightNeighborhood") {
distance = EightNeighborhood;
} else if (str == "FourNeighborhood") {
distance = FourNeighborhood;
} else if (str == "EuclideanSqr") {
distance = EuclideanSqr;
} else if (str == "Euclidean") {
distance = Euclidean;
} else if (str == "EightSED") {
distance = EightSED;
} else if (str == "EightSEDSqr") {
distance = EightSEDSqr;
} else if (str == "FourSED") {
distance = FourSED;
} else if (str == "FourSEDSqr") {
distance = FourSEDSqr;
} else {
distance = EightNeighborhood;
}
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && morphology::parameters::read(handler,false);
# else
bool (morphology::parameters::* p_readMS)(ioHandler&,const bool) =
morphology::parameters::readMS;
b = b && (this->*p_readMS)(handler,false);
# endif
if (complete) {
b = b && handler.readEnd();
}
return b;
}
const bool complete) const
# else
bool svm::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
if (kernel != 0) {
std::string kernelName;
cn.get(kernel,kernelName);
b=b && lti::write(handler, "haveKernel", true);
b=b && lti::write(handler, "kernelType", kernelName);
b=b && lti::write(handler, "kernelParam", kernel->getParameters());
} else {
b=b && lti::write(handler, "haveKernel", false);
b=b && lti::write(handler, "kernelType", "unknown");
}
b=b && lti::write(handler,"nSupport",nSupport);
b=b && lti::write(handler, "C", C);
b=b && lti::write(handler, "bias", bias);
b=b && lti::write(handler, "tolerance", tolerance);
b=b && lti::write(handler, "epsilon", epsilon);
b=b && lti::write(handler, "sumToOne", sumToOne);
b=b && lti::write(handler, "usePairwise", usePairwise);
b=b && lti::write(handler, "normalizeData", normalizeData);
//lti::write(handler, "useKernelVector",useKernelVector);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && supervisedInstanceClassifier::parameters::write(handler,false);
# else
bool (supervisedInstanceClassifier::parameters::* p_writeMS)(ioHandler&,const bool) const =
supervisedInstanceClassifier::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
/*
* read the classifier from the given ioHandler
*/
bool svm::read(ioHandler& handler,const bool complete) {
bool b=true;
if (complete) {
b=handler.readBegin();
}
b = b && supervisedInstanceClassifier::read(handler,false);
if (b) {
b=b && lti::read(handler, "nClasses",nClasses);
b=b && lti::read(handler, "alpha",alpha);
delete trainData;
dmatrix* t=new dmatrix();
b=b && lti::read(handler, "vectors",*t);
trainData=t;
b=b && lti::read(handler, "idMap",idMap);
b=b && lti::read(handler, "rIdMap",rIdMap);
b=b && lti::read(handler, "srcIds",srcIds);
b=b && lti::read(handler, "bias", bias);
int n;
b=b && lti::read(handler, "nKernels", n);
//kernels.
b=b && handler.readBegin();
b=b && handler.trySymbol("kernels");
className cn;
std::string kname;
kernels.resize(n);
// always read the complete kernel vector, so we have the setup
// ready to go without the need for any subsequent
// initializations
for (int i=0; i<n; i++) {
b=b && lti::read(handler, "name", kname);
if (kname != "unknown") {
kernels[i]=getParameters().createKernel(kname);
b=b && kernels[i]->read(handler);
} else {
kernels[i]=0;
}
}
b=b && handler.readEnd();
b=b && lti::read(handler, "offset", offset);
b=b && lti::read(handler, "scale", scale);
rebuildTargets();
defineOutputTemplate();
}
if (complete) {
b=b && handler.readEnd();
}
return b;
}
const bool complete) const
# else
bool camera::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
lti::write(handler,"autoWhiteBalance",autoWhiteBalance);
lti::write(handler,"autoGain",autoGain);
lti::write(handler,"gain",gain);
lti::write(handler,"redGain",redGain);
lti::write(handler,"blueGain",blueGain);
lti::write(handler,"minGain",minGain);
lti::write(handler,"maxGain",maxGain);
lti::write(handler,"minRBGain",minRBGain);
lti::write(handler,"maxRBGain",maxRBGain);
lti::write(handler,"autoShutter",autoShutter);
lti::write(handler,"shutterSpeed",shutterSpeed);
lti::write(handler,"minShutterSpeed",minShutterSpeed);
lti::write(handler,"maxShutterSpeed",maxShutterSpeed);
lti::write(handler,"autoFocus",autoFocus);
lti::write(handler,"focus",focus);
lti::write(handler,"minFocus",minFocus);
lti::write(handler,"maxFocus",maxFocus);
lti::write(handler,"zoom",zoom);
lti::write(handler,"maxZoom",maxZoom);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && functor::parameters::write(handler,false);
# else
bool (functor::parameters::* p_writeMS)(ioHandler&,const bool) const =
functor::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
const bool complete) const
# else
bool ioLTI::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && ioFunctor::parameters::write(handler,false);
# else
bool (ioFunctor::parameters::* p_writeMS)(ioHandler&,const bool) const =
ioFunctor::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
std::string tmp;
switch (compression) {
case ioLTI::None:
tmp="None";
break;
case ioLTI::Flate:
tmp="Flate";
break;
case ioLTI::RunLength:
tmp="RunLength";
break;
default:
// error
tmp="None";
break;
}
lti::write(handler, "compression", tmp);
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
const bool complete) const
# else
bool brightRGB::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
switch (type) {
case Minimum:
b = b && lti::write(handler,"type","Minimum");
break;
case Maximum:
b = b && lti::write(handler,"type","Maximum");
break;
case Median:
b = b && lti::write(handler,"type","Median");
break;
case Average:
b = b && lti::write(handler,"type","Average");
break;
default:
b = b && lti::write(handler,"type","Average");
}
b = b && lti::write(handler,"transparent",transparent);
b = b && lti::write(handler,"transColor",transColor);
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && globalFeatureExtractor::parameters::write(handler,false);
# else
bool (globalFeatureExtractor::parameters::* p_writeMS)
(ioHandler&,const bool) const =
globalFeatureExtractor::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
/*
* write function for ePointSetNormalizationType.
*
* @ingroup gStorable
*/
bool write(ioHandler& handler,const ePointSetNormalizationType& data) {
bool b=false;
switch(data) {
case IsotropicNormalization:
b=handler.write("IsotropicNormalization");
break;
case NoPointSetNormalization:
b=handler.write("NoPointSetNormalization");
break;
default:
b=handler.write("Unkown");
b=false;
break;
}
return b;
}
const bool complete) const
# else
bool panTiltUnit::parameters::writeMS(ioHandler& handler,
const bool complete) const
# endif
{
bool b = true;
if (complete) {
b = handler.writeBegin();
}
if (b) {
switch (angleFormat) {
case Degrees:
lti::write(handler,"angleFormat","Degrees");
break;
default:
lti::write(handler,"angleFormat","Radiant");
break;
}
lti::write(handler,"pan",pan);
lti::write(handler,"tilt",tilt);
lti::write(handler,"relativeMovement", relativeMovement);
lti::write(handler,"minPan", minPan);
lti::write(handler,"maxPan", maxPan);
lti::write(handler,"minTilt", minTilt);
lti::write(handler,"maxTilt", maxTilt);
}
# ifndef _LTI_MSC_6
// This is the standard C++ code, which MS Visual C++ 6 is not able to
// compile...
b = b && functor::parameters::write(handler,false);
# else
bool (functor::parameters::* p_writeMS)(ioHandler&,const bool) const =
functor::parameters::writeMS;
b = b && (this->*p_writeMS)(handler,false);
# endif
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
bool centroidClustering::write(ioHandler& handler,const bool complete) const {
bool b(true);
if (complete) {
b = handler.writeBegin();
}
// write the standard data (output and parameters)
b = b && clustering::write(handler,false);
b = b && lti::write(handler,"centroids",centroids);
if (complete) {
b = b && handler.writeEnd();
}
return b;
}
