Ceres Solver传入double数组却得到Jet<double,6>类型问题咨询

Hey there! Let's break down why you're hitting this Jet<double,6> type mismatch and how to fix it smoothly.

Why This Happens #

Ceres Solver's AutoDiffCostFunction relies on automatic differentiation to calculate derivatives for your optimization problem. Under the hood, it wraps your input parameters in a special Jet type—this type tracks both the variable's value and its partial derivatives relative to each optimization parameter (the 6 in Jet<double,6> matches your 6-dimensional param array).

The root issue is your Opt struct is hardcoded to use double for all members and constructor arguments. When Ceres tries to instantiate Opt with Jet<double,6> (to compute derivatives), it can't convert a Jet to a double to pass to your constructor—hence the type error you're seeing.

The Fix: Make Your Cost Function Template-Aware #

To fix this, you need to adjust your Opt struct to be a template that works with any numeric type (whether double or Jet). Here's how to update your code:

Step 1: Rewrite the Opt Struct as a Template #

template<typename T>
struct Opt {
    // Use template type T instead of fixed double for all members
    const T ptX, ptY, ptZ, nsX, nsY, nsZ, ds, w;

    // Constructor now accepts T-type arguments
    Opt(T ptx, T pty, T ptz, T nsx, T nsy, T nsz, T ds1, T weight)
        : ptX(ptx), ptY(pty), ptZ(ptz), nsX(nsx), nsY(nsy), nsZ(nsz), ds(ds1), w(weight) {}

    // Operator() also uses T for parameters and residual output
    bool operator()(const T* param, T* residual) const {
        // Your residual calculation logic here—use T everywhere instead of double
        // Example logic (adjust to match your actual formula):
        residual[0] = w * ((param[0] * ptX + param[1] * ptY + param[2] * ptZ + param[3]) 
                          - (nsX * param[4] + nsY * param[5] + ds));
        return true;
    }
};

Step 2: Update the AddResidualBlock Call #

When creating the AutoDiffCostFunction, specify Opt<double> as the cost function type (Ceres will automatically handle the Jet instantiation internally):

problem.AddResidualBlock(
    new ceres::AutoDiffCostFunction<Opt<double>, 1, 6>(
        new Opt<double>(
            Pts[i][j].x, Pts[i][j].y, Pts[i][j].z,
            Ns[i].at<double>(0, 0), Ns[i].at<double>(1, 0), Ns[i].at<double>(2, 0),
            Ds[i], weights[i]
        )
    ),
    NULL,
    param
);

Key Reminders #

• The template approach lets Ceres use Jet<double,6> when computing derivatives and double when evaluating just the residual value.
• Ensure every part of your residual calculation in operator() uses the template type T—don't hardcode double anywhere in that logic, or you'll break the automatic differentiation pipeline.

内容的提问来源于stack exchange，提问作者zhouuu