/* * 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; }
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 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 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 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 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 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; }
// 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; }
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; }
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 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 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; }
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 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 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 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; }
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 camera::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } if (b) { float dummy; 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",dummy); lti::write(handler,"maxGain",dummy); lti::write(handler,"minRBGain",dummy); lti::write(handler,"maxRBGain",dummy); lti::write(handler,"autoShutter",autoShutter); lti::write(handler,"shutterSpeed",shutterSpeed); lti::write(handler,"minShutterSpeed",dummy); lti::write(handler,"maxShutterSpeed",dummy); lti::write(handler,"autoFocus",autoFocus); lti::write(handler,"focus",focus); lti::write(handler,"minFocus",dummy); lti::write(handler,"maxFocus",dummy); lti::write(handler,"zoom",zoom); lti::write(handler,"maxZoom",dummy); } # 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 brightRGB::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } std::string str; b = b && lti::read(handler,"type",str); if (str == "Minimum") { type = Minimum; } else if (str == "Maximum") { type = Maximum; } else if (str == "Average") { type = Average; } else if (str == "Median") { type = Median; } else { type = Average; } b = b && lti::read(handler,"transparent",transparent); b = b && lti::read(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::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 fuzzyCMeans::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } if (b) { lti::read(handler,"fuzzifier",fuzzifier); // lti::read(handler,"norm",norm); lti::read(handler,"epsilon",epsilon); lti::read(handler,"maxIterations",maxIterations); lti::read(handler,"nbOfClusters",nbOfClusters); std::string str; lti::read(handler,"norm",str); if (str == "L1distance") { norm = L1; } else if (str == "L2distance") { norm = L2; } else { norm = L2; } } # ifndef _LTI_MSC_6 // This is the standard C++ code, which MS Visual C++ 6 is not able to // compile... b = b && centroidClustering::parameters::read(handler,false); # else bool (centroidClustering::parameters::* p_readMS)(ioHandler&,const bool) = centroidClustering::parameters::readMS; b = b && (this->*p_readMS)(handler,false); # endif if (complete) { b = b && handler.readEnd(); } return b; }
bool panTiltUnit::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } if (b) { std::string str; float dummy; lti::read(handler,"angleFormat",str); if (str == "Degrees") angleFormat = Degrees; else angleFormat = Radiant; //default lti::read(handler,"pan", pan); lti::read(handler,"tilt", tilt); lti::read(handler,"relativeMovement", relativeMovement); lti::read(handler,"minPan", dummy); lti::read(handler,"maxPan", dummy); lti::read(handler,"minTilt", dummy); lti::read(handler,"maxTilt", dummy); } # 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; }
/* * read the parameters from the given ioHandler * @param handler the ioHandler to be used * @param complete if true (the default) the enclosing begin/end will * be also read, otherwise only the data block will be read. * @return true if read was succeful */ bool cwagmSegmentationEvaluation::parameters::read(ioHandler& handler, const bool& complete) { bool b = true; if (complete) { b = handler.readBegin(); } if (b) { lti::read(handler,"minValues",minValues); lti::read(handler,"maxValues",maxValues); } b = b && segmentationEvaluation::parameters::read(handler,false); if (complete) { b = b && handler.readEnd(); } return b; }
bool centroidClustering::read(ioHandler& handler,const bool complete) { bool b(true); if (complete) { b = handler.readBegin(); } // read the standard data (output and parameters) b = b && clustering::read(handler,false); b = b && lti::read(handler,"centroids",centroids); if (complete) { b = b && handler.readEnd(); } return b; }
bool SOFM::read(ioHandler& handler,const bool complete) { bool b(true); if (complete) { b = handler.readBegin(); } // read the standard data (output and parameters) unsupervisedClassifier::read(handler,false); if (b) { lti::read(handler,"grid",grid); } if (complete) { b = b && handler.readEnd(); } return b; }
bool shClassifier::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } _lti_debug("b="<<b<<","); if (b) { b=b && lti::read(handler, "numberOfBins",numberOfBins); _lti_debug("b="<<b<<","); b=b && lti::read(handler, "binVector",binVector); _lti_debug("b="<<b<<","); b=b && lti::read(handler, "minimum",minimum); _lti_debug("b="<<b<<","); b=b && lti::read(handler, "maximum",maximum); _lti_debug("b="<<b<<","); b=b && lti::read(handler, "autoBounds", autoBounds); } _lti_debug("b="<<b<<","); # 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(); } _lti_debug("b="<<b<<","); return b; }
bool ioLTI::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 && ioFunctor::parameters::read(handler,false); # else bool (ioFunctor::parameters::* p_readMS)(ioHandler&,const bool) = ioFunctor::parameters::readMS; b = b && (this->*p_readMS)(handler,false); # endif std::string tmp; lti::read(handler, "compression", tmp); if (tmp == "None") { compression=None; } else if (tmp == "RunLength") { compression=RunLength; } else if (tmp == "Flate") { compression=Flate; } else { // ERROR compression=None; } if (complete) { b = b && handler.readEnd(); } return b; }
bool SOFM2D::read(ioHandler& handler,const bool complete) { bool b(true); if (complete) { b = handler.readBegin(); } // read the standard data (output and parameters) SOFM::read(handler,false); if (b) { lti::read(handler,"sizeX",sizeX); lti::read(handler,"sizeY",sizeY); } if (complete) { b = b && handler.readEnd(); } return b; }
/* * read the classifier from the given ioHandler */ bool shClassifier::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, "idMap",idMap); b=b && lti::read(handler, "rIdMap",rIdMap); _lti_debug("B1 = " << b << " in " << this << "\n"); models.resize(nClasses); if (getParameters().binVector.size() > 0) { const ivector& bvect=getParameters().binVector; for (int i=0; i<nClasses; i++) { models[i]=new sparseHistogram(bvect); b=b && models[i]->read(handler); } _lti_debug("B2 = " << b << "\n"); } else { int bins=getParameters().numberOfBins; for (int i=0; i<nClasses; i++) { models[i]=new sparseHistogram(bins,0); b=b && models[i]->read(handler); } _lti_debug("B3 = " << b << "\n"); } //b=b && handler.readEnd(); } if (complete) { b=b && handler.readEnd(); } return b; }
bool harrisCorners::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } if (b) { lti::read(handler,"variance",variance); lti::read(handler,"kernelSize",kernelSize); lti::read(handler,"maximumCorners",maximumCorners); lti::read(handler,"scale",scale); lti::read(handler,"localMaximaParameters",localMaximaParameters); lti::read(handler,"gradientFunctorParameters", gradientFunctorParameters); } # ifndef _LTI_MSC_6 // This is the standard C++ code, which MS Visual C++ 6 is not able to // compile... b = b && cornerDetector::parameters::read(handler,false); # else bool (cornerDetector::parameters::* p_readMS)(ioHandler&,const bool) = cornerDetector::parameters::readMS; b = b && (this->*p_readMS)(handler,false); # endif if (complete) { b = b && handler.readEnd(); } return b; }
bool sffs::parameters::readMS(ioHandler& handler, const bool complete) # endif { bool b = true; if (complete) { b = handler.readBegin(); } if (b) { usedCostFunction->read(handler,false); // std::string str; // lti::read(handler,"classifier",str); // const supervisedInstanceClassifier* types[] = { new rbf, new lvq, // new svm, new shClassifier, new manualCrispDecisionTree, 0 }; // objectFactory<supervisedInstanceClassifier> objFac(types); // classifier = objFac.newInstance(str); } # ifndef _LTI_MSC_6 // This is the standard C++ code, which MS Visual C++ 6 is not able to // compile... b = b && featureSelector::parameters::read(handler,false); # else bool (featureSelector::parameters::* p_readMS)(ioHandler&,const bool) = featureSelector::parameters::readMS; b = b && (this->*p_readMS)(handler,false); # endif if (complete) { b = b && handler.readEnd(); } return b; }