解决自定义分类器总是返回已知类别的问题：多阶段分类策略

private void classifyImage(Bitmap image) {
    // 步骤1: 图像预处理 (与现有代码类似)
    // ... 省略图像尺寸调整、像素读取、ByteBuffer填充等现有代码 ...
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4 * imageSize * imageSize * 3);
    byteBuffer.order(ByteOrder.nativeOrder());

    int[] intValue = new int[imageSize * imageSize];
    image.getPixels(intValue, 0, image.getWidth(), 0, 0, image.getWidth(), image.getHeight());

    int pixel = 0;
    for (int i = 0; i < imageSize; i++) {
        for (int j = 0; j < imageSize; j++) {
            int val = intValue[pixel++];
            byteBuffer.putFloat(((val >> 16) & 0xFF) * (1.f / 255.f));
            byteBuffer.putFloat(((val >> 8) & 0xFF) * (1.f / 255.f));
            byteBuffer.putFloat((val & 0xFF) * (1.f / 255.f));
        }
    }

    // 假设我们有一个独立的二元分类器模型，例如 "IsPlantDetector"
    // 这个模型会判断图像是否包含植物（或水果）
    // 为了简化，这里仅作概念性演示
    boolean isPlantDetected = runBinaryClassifier(byteBuffer); // 传入处理好的图像数据

    if (!isPlantDetected) {
        // 如果二元分类器判断不是植物，则直接显示无检测结果
        result.setText("未检测到植物");
        confidence.setVisibility(View.GONE); // 隐藏置信度信息
        return; // 提前退出，不再进行多类别分类
    }

    // 步骤2: 如果是植物，则进行多类别分类（原有的水果疾病分类逻辑）
    try {
        FruitDisease model = FruitDisease.newInstance(getApplicationContext());

        TensorBuffer inputFeature = TensorBuffer.createFixedSize(new int[]{1, 224, 224, 3}, DataType.FLOAT32);
        inputFeature.loadBuffer(byteBuffer); // 使用之前填充的byteBuffer

        FruitDisease.Outputs outputs = model.process(inputFeature);
        TensorBuffer outputFeature0 = outputs.getOutputFeature0AsTensorBuffer();

        float[] confidences = outputFeature0.getFloatArray();
        int maxPos = 0;
        float maxConfidence = 0;
        for (int i = 0; i < confidences.length; i++) {
            if (confidences[i] > maxConfidence) {
                maxConfidence = confidences[i];
                maxPos = i;
            }
        }

        String[] classes = {"Watermelon Healthy", "Watermelon Blossom End Rot", "Watermelon Anthracnose",
                "Mango Healthy", "Mango Bacterial Canker", "Mango Anthracnose",
                "Orange Scab", "Orange Healthy",
                "Orange Bacterial Citrus Canker", "Banana Healthy", "Banana Crown Rot",
                "Banana Anthracnose", "Apple Scab", "Apple Healthy", "Apple Black Rot Canker"};

        result.setText(classes[maxPos]);
        String s = "";
        // 改进：只显示前几个置信度高的结果，或者所有结果，但不要在循环内重复设置confidence.setText
        for (int i = 0; i < classes.length; i++) {
            s += String.format("%s: %.1f%%\n", classes[i], confidences[i] * 100);
        }
        confidence.setText(s);
        confidence.setVisibility(View.VISIBLE);

        // 关闭模型以释放资源
        model.close();

    } catch (Exception e) {
        // 错误处理
        result.setText("分类失败: " + e.getMessage());
        confidence.setVisibility(View.GONE);
        e.printStackTrace();
    }
}

/**
 * 这是一个概念性的方法，用于运行二元分类器。
 * 在实际应用中，您会在这里加载并运行一个单独的TFLite模型，
 * 该模型专门用于判断图像是否包含目标对象（如植物或水果）。
 *
 * @param inputBuffer 已经预处理好的图像数据
 * @return 如果检测到目标对象（如植物），则返回 true；否则返回 false。
 */
private boolean runBinaryClassifier(ByteBuffer inputBuffer) {
    // 实际实现中，这里会加载并运行一个名为 "IsPlantDetector.tflite" 的模型
    // 假设该模型输出一个表示“是植物”的概率
    // 如果该概率高于某个阈值（例如 0.7），则返回 true

    // 示例伪代码:
    // try {
    //     IsPlantDetector detectorModel = IsPlantDetector.newInstance(getApplicationContext());
    //     TensorBuffer detectorInput = TensorBuffer.createFixedSize(new int[]{1, 224, 224, 3}, DataType.FLOAT32);
    //     detectorInput.loadBuffer(inputBuffer);
    //
    //     IsPlantDetector.Outputs detectorOutputs = detectorModel.process(detectorInput);
    //     TensorBuffer outputFeature = detectorOutputs.getOutputFeature0AsTensorBuffer();
    //     float[] probabilities = outputFeature.getFloatArray(); // 假设第一个元素是“不是植物”，第二个是“是植物”
    //
    //     detectorModel.close();
    //
    //     // 假设第二个概率值代表“是植物”的置信度
    //     return probabilities[1] > 0.7; // 设置一个置信度阈值
    // } catch (Exception e) {
    //     Log.e("BinaryClassifier", "Error running binary classifier", e);
    //     return false; // 发生错误时默认为未检测到
    // }

    // 目前仅作演示，假设总是检测到植物，以便后续多类别分类能运行
    return true;
}