C++ copyTo函数代码示例

frenzy::dom::Nodep
frenzy::dom::Attr::cloneNode(bool deep) const
{
  Attrp ret = Attr::create(name);
  copyTo(ret, deep);
  return ret;
}

void UMat::convertTo(OutputArray _dst, int _type, double alpha, double beta) const
{
    bool noScale = std::fabs(alpha - 1) < DBL_EPSILON && std::fabs(beta) < DBL_EPSILON;
    int stype = type(), cn = CV_MAT_CN(stype);

    if( _type < 0 )
        _type = _dst.fixedType() ? _dst.type() : stype;
    else
        _type = CV_MAKETYPE(CV_MAT_DEPTH(_type), cn);

    int sdepth = CV_MAT_DEPTH(stype), ddepth = CV_MAT_DEPTH(_type);
    if( sdepth == ddepth && noScale )
    {
        copyTo(_dst);
        return;
    }
#ifdef HAVE_OPENCL
    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;
    bool needDouble = sdepth == CV_64F || ddepth == CV_64F;
    if( dims <= 2 && cn && _dst.isUMat() && ocl::useOpenCL() &&
            ((needDouble && doubleSupport) || !needDouble) )
    {
        int wdepth = std::max(CV_32F, sdepth), rowsPerWI = 4;

        char cvt[2][40];
        ocl::Kernel k("convertTo", ocl::core::convert_oclsrc,
                      format("-D srcT=%s -D WT=%s -D dstT=%s -D convertToWT=%s -D convertToDT=%s%s%s",
                             ocl::typeToStr(sdepth), ocl::typeToStr(wdepth), ocl::typeToStr(ddepth),
                             ocl::convertTypeStr(sdepth, wdepth, 1, cvt[0]),
                             ocl::convertTypeStr(wdepth, ddepth, 1, cvt[1]),
                             doubleSupport ? " -D DOUBLE_SUPPORT" : "", noScale ? " -D NO_SCALE" : ""));
        if (!k.empty())
        {
            UMat src = *this;
            _dst.create( size(), _type );
            UMat dst = _dst.getUMat();

            float alphaf = (float)alpha, betaf = (float)beta;
            ocl::KernelArg srcarg = ocl::KernelArg::ReadOnlyNoSize(src),
                    dstarg = ocl::KernelArg::WriteOnly(dst, cn);

            if (noScale)
                k.args(srcarg, dstarg, rowsPerWI);
            else if (wdepth == CV_32F)
                k.args(srcarg, dstarg, alphaf, betaf, rowsPerWI);
            else
                k.args(srcarg, dstarg, alpha, beta, rowsPerWI);

            size_t globalsize[2] = { (size_t)dst.cols * cn, ((size_t)dst.rows + rowsPerWI - 1) / rowsPerWI };
            if (k.run(2, globalsize, NULL, false))
            {
                CV_IMPL_ADD(CV_IMPL_OCL);
                return;
            }
        }
    }
#endif
    Mat m = getMat(ACCESS_READ);
    m.convertTo(_dst, _type, alpha, beta);
}

HBaseStyle* HImageStyle::clone()
{
    HImageStyle* style = new HImageStyle(HObjectInfo(styleId(),""),parent());
    copyTo(style);

    return style;
}

boost::shared_ptr<IParticleSystem> PointArrayParticleSystem::clone()
{
    PointArrayParticleSystem* ps = new PointArrayParticleSystem();
    copyTo(*ps);
    ps->m_eds = m_eds;
    ps->m_parray = m_parray;
    boost::shared_ptr<IParticleSystem> ptr(ps);

#ifdef PHYSICS_PHYSX
#ifndef NX_DISABLE_FLUIDS

    if(!fluid && physics && (m_eds->physicsType == GenParticleSystemEditables::PHYSICS_TYPE_FLUID || m_eds->physicsType == GenParticleSystemEditables::PHYSICS_TYPE_FLUID_INTERACTION))
    {
        int collGroup = PHYSICS_COLLISIONGROUP_FLUIDS;
        if (m_eds->fluidDetailCollisionGroup)
        {
            collGroup = PHYSICS_COLLISIONGROUP_FLUIDS_DETAILED;
        }
        fluid = physics->createFluid(m_eds->physicsType - 2, m_eds->maxParticles * m_eds->fluidMaxEmitterAmount, m_eds->fluidStaticRestitution, m_eds->fluidStaticRestitution, m_eds->fluidDynamicRestitution, m_eds->fluidDynamicAdhesion, m_eds->fluidDamping, m_eds->fluidStiffness, m_eds->fluidViscosity, m_eds->fluidKernelRadiusMultiplier, m_eds->fluidRestParticlesPerMeter, m_eds->fluidRestDensity, m_eds->fluidMotionLimit, m_eds->fluidPacketSizeMultiplier, collGroup);
        if(fluid)
            m_render_fluid_parts.reset(new std::vector<Particle> (m_eds->maxParticles * m_eds->fluidMaxEmitterAmount));
    }

    ps->fluid = fluid;
    ps->m_render_fluid_parts = m_render_fluid_parts;

#endif
#endif

    return ptr;
}

bool ServerConfigurationDialog::testConnection()
{
   bool okay(false);

   if (!copyTo(&m_currentConfiguration)) return okay;

   switch (m_currentConfiguration.connection()) {
      case ServerConfiguration::Local:
         QMsgBox::information(this, "IQmol", "Local connection just fine");
         break;
      case ServerConfiguration::SSH:
         okay = testSshConnection(m_currentConfiguration);
         break;
      case ServerConfiguration::HTTP:
      case ServerConfiguration::HTTPS:
         okay = testHttpConnection(m_currentConfiguration);
         break;
   }

   if (okay) {
      QMsgBox::information(0, "IQmol", "Connection successful");
      m_tested = true;
   }

   return okay;
}

inline
GpuMat GpuMat::clone() const
{
    GpuMat m;
    copyTo(m);
    return m;
}

ISecUser * CLdapSecUser::clone()
{
    CLdapSecUser* newuser = new CLdapSecUser(m_name.get(), m_pw.get());
    if(newuser)
        copyTo(*newuser);
    return newuser;
}

 LeafMatchExpression* InMatchExpression::shallowClone() const {
     InMatchExpression* next = new InMatchExpression();
     copyTo( next );
     if ( getTag() ) {
         next->setTag(getTag()->clone());
     }
     return next;
 }

void View::onRefresh(RectList *rects, M4Surface *destSurface) {
	assert(destSurface);

	if (rects == NULL)
		// No rect list specified, so copy entire surface
		copyTo(destSurface, _coords.left, _coords.top, _transparent ? 0 : -1);
	else {
		// Loop through the set of specified rectangles
		RectList::iterator i;
		for (i = rects->begin(); i != rects->end(); ++i) {
			Common::Rect &destRect = *i;
			Common::Rect srcBounds(destRect.left - _coords.left, destRect.top - _coords.top,
				destRect.right - _coords.left, destRect.bottom - _coords.top);
			copyTo(destSurface, srcBounds, destRect.left, destRect.top, _transparent ? 0 : -1);
		}
	}
}

 ISecResourceList * clone()
 {
     ISecResourceList* _newList = new CSecurityResourceList(m_name.get());
     if(!_newList)
         return NULL;
     copyTo(*_newList);
     return _newList;
 }

std::unique_ptr<MatchExpression> InMatchExpression::shallowClone() const {
    std::unique_ptr<InMatchExpression> next = stdx::make_unique<InMatchExpression>();
    copyTo(next.get());
    if (getTag()) {
        next->setTag(getTag()->clone());
    }
    return std::move(next);
}

ISecResourceList * CLdapSecResourceList::clone()
{
    CLdapSecResourceList* _newList = new CLdapSecResourceList(m_name.get());
    if(!_newList)
        return NULL;
    copyTo(*_newList);
    return _newList;
}

// Apply data to current
bool CAreaConfiguration::restore(CParameterBlackboard* pMainBlackboard, bool bSync, list<string>* plstrError) const
{
    assert(_bValid);

    copyTo(pMainBlackboard, _pConfigurableElement->getOffset());

    // Synchronize if required
    return !bSync || _pSyncerSet->sync(*pMainBlackboard, false, plstrError);
}

 ISecUser * clone()
 {
     //DBGLOG("Beginning of clone()");
     CSecureUser* newuser = new CSecureUser(m_name.str(), m_pw.str());
     //DBGLOG("Before copy to");
     if(newuser)
         copyTo(*newuser);
 //DBGLOG("After copy to");
     return newuser;
 }

cv::Mat EMat::AppendRight(cv::Mat &src, cv::Mat &dst) {
    assert(src.rows == rows);

    if ((dst.rows < src.rows) || (dst.cols < src.cols + cols))
        dst.create(src.rows, src.cols + cols, type());

    cv::Mat left = dst(cv::Range(0, src.rows), cv::Range(0, cols));
    cv::Mat right = dst(cv::Range(0, src.rows), cv::Range(cols, src.cols + cols));

    copyTo(left);
    src.copyTo(right);
    return dst(cv::Range(0, rows), cv::Range(0, src.cols + cols));
}