C++ ioHandler::writeBegin方法代码示例

                                         const bool complete) const
# else
  bool fastViewer::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {
      lti::write(handler, "topleft", topleft);
      lti::write(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::write(handler,false);
# else
    bool (viewerBase::parameters::* p_writeMS)(ioHandler&,const bool) const =
      viewerBase::parameters::writeMS;
    b = b && (this->*p_writeMS)(handler,false);
# endif

    if (complete) {
      b = b && handler.writeEnd();
    }

    return b;
  }

                                         const bool complete) const
# else
  bool huMoments::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {

      lti::write(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::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;
  }

                                         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 labelAdjacencyMap::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {

      lti::write(handler,"minColors",minColors);
      lti::write(handler,"thePalette",thePalette);
      lti::write(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::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 sigmoidKernel::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {
      b=b && lti::write(handler, "kappa", kappa);
      b=b && lti::write(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::write(handler,false);
# else
    bool (kernelFunctor<double>::parameters::* p_writeMS)(ioHandler&,const bool) const =
      kernelFunctor<double>::parameters::writeMS;
    b = b && (this->*p_writeMS)(handler,false);
# endif

    if (complete) {
      b = b && handler.writeEnd();
    }

    return b;
  }

                                         const bool complete) const
# else
  bool homography8DofEstimator::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 && homographyEstimatorBase::parameters::write(handler,false);
# else
    bool (homographyEstimatorBase::parameters::* p_writeMS)
      (ioHandler&,const bool) const =
      homographyEstimatorBase::parameters::writeMS;
    b = b && (this->*p_writeMS)(handler,false);
# endif

    if (complete) {
      b = b && handler.writeEnd();
    }

    return b;
  }

                                         const bool complete) const
# else
  bool regionMerge::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {

      lti::write(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::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 medianCut::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {

      lti::write(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::write(handler,false);
# else
    bool (colorQuantization::parameters::* p_writeMS)(ioHandler&,
                                                      const bool) const =
      colorQuantization::parameters::writeMS;
    b = b && (this->*p_writeMS)(handler,false);
# endif

    if (complete) {
      b = b && handler.writeEnd();
    }

    return b;
  }

                                         const bool complete) const
# else
  bool SOFM2D::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {

      lti::write(handler,"area",area);
      lti::write(handler,"sizeX",sizeX);
      lti::write(handler,"sizeY",sizeY);
      lti::write(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::write(handler,false);
# else
    bool (SOFM::parameters::* p_writeMS)(ioHandler&,const bool) const =
      SOFM::parameters::writeMS;
    b = b && (this->*p_writeMS)(handler,false);
# endif

    if (complete) {
      b = b && handler.writeEnd();
    }

    return b;
  }

                                         const bool complete) const
# else
  bool kNearestNeighFilter::parameters::writeMS(ioHandler& handler,
                                           const bool complete) const
# endif
  {
    bool b = true;
    if (complete) {
      b = handler.writeBegin();
    }

    if (b) {

	lti::write(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::write(handler,false);
# else
    bool (filter::parameters::* p_writeMS)(ioHandler&,const bool) const =
      filter::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;
  }

                               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 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;
  }

  /*
   * write the classifier in the given ioHandler
   */
  bool svm::write(ioHandler& handler,const bool complete) const {
    bool b=true;
    if (complete) {
      b=handler.writeBegin();
    }
    b = b && supervisedInstanceClassifier::write(handler,false);
    if (b) {
      b=b && lti::write(handler, "nClasses",nClasses);
      b=b && lti::write(handler, "alpha",alpha);
      b=b && lti::write(handler, "vectors",*trainData);
      b=b && lti::write(handler, "idMap",idMap);
      b=b && lti::write(handler, "rIdMap",rIdMap);
      b=b && lti::write(handler, "srcIds",srcIds);
      b=b && lti::write(handler, "bias", bias);
      b=b && lti::write(handler, "nKernels", kernels.size());
      b=b && handler.writeBegin();
      b=b && lti::write(handler, "kernels");
      b=b && handler.writeDataSeparator();
      className cn;
      std::string kname;
      // always write the complete kernel vector, so we do not need
      // to remember which training methods has been used.
      for (unsigned int i=0; i<kernels.size(); i++) {
        if (kernels[i] != 0) {
          cn.get(kernels[i],kname);
          lti::write(handler,"name",kname);
          b=b && kernels[i]->write(handler);
        } else {
          lti::write(handler,"name","unknown");
        }
      }
      b=b && handler.writeEnd();
      b=b && lti::write(handler, "offset", offset);
      b=b && lti::write(handler, "scale", scale);

    }
    if (complete) {
      b=handler.writeEnd();
    }
    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;
  }