按照以下步骤，编写一个光谱角监督分类的C++算法：（1）以图像中已知类型的区域为参考光谱，将区域中光谱的几何平均向量作为类中心。 （2）计算未知像元与各类中心的夹角（相关系数）。 （3）通过多次实验分别对不同的类别设置不同的阙值。若设置的阈值大于（小于）计算得出的光谱角度（相关系数），则不对该像元进行分类。 （4）将给未知像元分类到夹角最小（系数最大）的类别中去。

以下是一个简单的光谱角监督分类的C++算法示例：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// 定义光谱向量类
class Spectrum {
public:
    vector<double> values;

    // 计算几何平均向量
    Spectrum mean(const vector<Spectrum>& spectra) {
        Spectrum result;
        int size = spectra.size();
        for (int i = 0; i < spectra[0].values.size(); i++) {
            double sum = 0;
            for (int j = 0; j < size; j++) {
                sum += spectra[j].values[i];
            }
            result.values.push_back(sum / size);
        }
        return result;
    }

    // 计算余弦相似度
    double cosine(const Spectrum& other) const {
        double dot = 0, mag1 = 0, mag2 = 0;
        for (int i = 0; i < values.size(); i++) {
            dot += values[i] * other.values[i];
            mag1 += values[i] * values[i];
            mag2 += other.values[i] * other.values[i];
        }
        return dot / (sqrt(mag1) * sqrt(mag2));
    }
};

// 定义分类器类
class SpectrumClassifier {
public:
    vector<vector<Spectrum>> classes;
    vector<double> thresholds;

    // 添加一个类别
    void addClass(const vector<Spectrum>& spectra) {
        classes.push_back(spectra);
    }

    // 训练分类器
    void train() {
        // 计算每个类别的几何平均向量
        vector<Spectrum> means;
        for (int i = 0; i < classes.size(); i++) {
            means.push_back(Spectrum().mean(classes[i]));
        }

        // 计算每个类别的阈值
        for (int i = 0; i < classes.size(); i++) {
            double max_cosine = -1;
            for (int j = 0; j < classes.size(); j++) {
                if (i == j) continue;
                double cosine = means[i].cosine(means[j]);
                if (cosine > max_cosine) {
                    max_cosine = cosine;
                }
            }
            thresholds.push_back(max_cosine);
        }
    }

    // 对一个样本进行分类
    int classify(const Spectrum& sample) const {
        double max_cosine = -1;
        int max_class = -1;
        for (int i = 0; i < classes.size(); i++) {
            double cosine = sample.cosine(Spectrum().mean(classes[i]));
            if (cosine > max_cosine && cosine > thresholds[i]) {
                max_cosine = cosine;
                max_class = i;
            }
        }
        return max_class;
    }
};

// 示例
int main() {
    // 添加两个类别
    vector<vector<Spectrum>> training_data(2);
    training_data[0].push_back({1, 2, 3});
    training_data[0].push_back({2, 3, 4});
    training_data[0].push_back({3, 4, 5});
    training_data[1].push_back({2, 3, 4});
    training_data[1].push_back({3, 4, 5});
    training_data[1].push_back({4, 5, 6});

    // 训练分类器
    SpectrumClassifier classifier;
    classifier.addClass(training_data[0]);
    classifier.addClass(training_data[1]);
    classifier.train();

    // 对一个样本进行分类
    Spectrum sample = {2, 3, 4};
    int class_id = classifier.classify(sample);
    cout << "Sample belongs to class " << class_id << endl;

    return 0;
}

在这个示例中，我们定义了一个`Spectrum`类表示光谱向量，以及一个`SpectrumClassifier`类表示分类器。在训练分类器时，我们先计算每个类别的几何平均向量，并计算每个类别的阈值。在对一个样本进行分类时，我们计算它与每个类别的几何平均向量之间的余弦相似度，并选取最大的相似度作为分类结果，但仅当它大于该类别的阈值时才进行分类。