{
    "ak": "Mz0zhObvEZ6lnG1K3renXXXX", // API Key的值
    "sk": "188fRHYvLPmlPrNCDpBnkhL3ydXXXXX", // Secret Key的值
    "apiUrl": "https://aip.baidubce.com/rpc/2.0/ai_custom_retail/v1/detection/XXXX"  // 定制商品检测服务API
}

/**
 * 获取实例
 *
 * @param appKey 网页上的应用的appkey
 * @param secretKey 网页上的应用的appSecret
 * @param apiUrl 商品检测服务API
 */
public static MobileStitchAPI getInstance(String appKey, String secretKey, String apiUrl);

/**
 * 获取实例
 *
 * @param appKey 网页上的应用的appkey
 * @param secretKey 网页上的应用的appSecret
 * @param apiUrl 商品检测服务API
 * @param numConcurrency 同时调用商品检测API的并发数
 */
public static MobileStitchAPI getInstance(String appKey, String secretKey, String apiUrl, int numConcurrency);

/**
 * 初始化API
 *
 * @param workDirPath 保存实时拼接过程产生的各类文件的路径
 */
public void init(String workDirPath);

/**
 * 对比当前图片与上一张参与拼接的图片
 *
 * @param currentImgBitmap 当前要参与对比的图片
 * @param firstFrame       是否是第一帧
 */
public void compareImages(Bitmap currentImgBitmap, boolean firstFrame);

// 当前图片相对上一张参与拼接的图片的方位，参考MobileStitchAPI.DIRECTION_{LEFT|UP|RIGHT|DOWN|UNKNOWN}
public int getDirection();

// 对比结果中的方位是否合法，非法的方位将无法完成拼接
public boolean isDirectionValid();

/**
 * 是否需要判断方向，如当拍摄完图片过近时，direction可能由于两图过于相似而不可靠，这种情况不需要判断方向，即该值=false
 * 一般direction不可靠时，该值=false
 * 对比的两张图是第一次对比时，该值=false
 * 当该值=true时，请在调用实时拼接API前确认方法是否合法
 */
public boolean needCheckDirection();

// 两张图片重叠部分的点位
public List<PointF> getPoints();

switch (compareResult.getOverlapStatus()) {
    case CompareResult.OVERLAP_CORRECT:
        if (compareResult.needCheckDirection() && !compareResult.isDirectionValid()) {
            // 非法，当前参与对比的图片方位不正确，无法拼接
        } else {
            // 合法
        }
        break;
    case CompareResult.OVERLAP_TOO_FAR:
        // 非法，两张图重叠度过低
        break;
    case CompareResult.OVERLAP_TOO_CLOSE:
        // 非法，两张图重叠度过高
        break;
}

/**
 * 拼接图片
 *
 * @param compareResult 对比图片回调返回的结果
 */
public void stitchImage(CompareResult compareResult);

// 获取缩略拼接图路径
public String getThumbnailPath();

// 获取完整拼接图路径
public String getFullImgPath();

// 获取最近一张参与拼接的图片的序号
public int getLatestPhotoIndex();

// 拼接是否成功
public boolean isSuccess();

// 1.原图
Bitmap bitmap = getFromSomewhere();

// 2.计算最佳缩放系数
float scaleFactor = calculateScaleFactor(bitmap);

// 3.缩放获得最佳尺寸的图片
Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, 
                                                (int) (bitmap.getWidth() * scaleFactor), 
                                                (int) (bitmap.getHeight() * scaleFactor),
                                                true);

// 4.保存
String fullImgFilepath = workDirPath + "/" 
                        + MobileStitchAPI.DIR_NAME_FULL_IMAGE + "/" 
                        + MobileStitchAPI.IMAGE_NAME_NOW;
ImageUtil.saveBitmap(scaledBitmap, fullImgFilepath);

/**
 * 计算最佳缩放系数
 */
private float calculateScaleFactor(Bitmap originalBitmap) {
    int longerSide;
    int shorterSide;
    if (originalBitmap.getWidth() > originalBitmap.getHeight()) {
        longerSide = originalBitmap.getWidth();
        shorterSide = originalBitmap.getHeight();
    } else {
        longerSide = originalBitmap.getHeight();
        shorterSide = originalBitmap.getWidth();
    }
    return Math.min(1333f / longerSide, 800f / shorterSide);
}

// 最后一张参与拼接的图片路径，workDirPath为初始化时工作目录路径
// latestPhotoIndex为最后一张参与拼接的图片序号，可在 MobileStitchAPIListener 以下回调时赋值
//      1. onAPIPrepared() - 参数takenPhotoSize
//      2. onStitchCompleted() - 参数result.getLatestPhotoIndex()
//      3. onDeletionConfirmed() - 参数latestPhotoIndex
String filepath = workDirPath + "/" + latestPhotoIndex + ".jpg";

// 删除图片
FileUtil.deleteFile(filepath);

// 通知SDK
// SDK确认删除后回调 MobileStitchAPIListener.onDeletionConfirmed(int, int[])
mobileStitchAPI.notifyLatestPhotoDeletion();

/**
 * 上传云端检测，并获得结果
 */
public void mergeDetectResults();

// 获取商品检测并去重后的结果
public String getCorrectedSKUJson();

/**
 * API准备好时的回调
 *
 * @param takenPhotoSize 工作目录下已拍摄的图像数量
 * @param latestPhotoPos 最新拍摄图片的坐标
 */
void onAPIPrepared(int takenPhotoSize, int[] latestPhotoPos);

/**
 * 图片对比完成
 *
 * @param compareResult 对比结果
 */
void onImagesCompared(CompareResult compareResult);

/**
 * 调用拼接接口后，缩略图生成后的回调
 *
 * @param thumbnailName 缩略图在工作目录下的文件名
 */
void onStitchThumbnailGenerated(String thumbnailName);

/**
 * 调用拼接接口后，完整拼接图片生成后的回调
 *
 * @param fullImageName 完成拼接图片在工作目录下的文件名
 */
void onStitchFullImageGenerated(String fullImageName);

/**
 * 拼接完成回调
 *
 * @param mobileStitchResult 拼接结果
 */
void onStitchCompleted(MobileStitchResult mobileStitchResult);

/**
 * 删除确认回调
 * 
 * @param latestPhotoIndex -1=操作失败，否则返回删除后，最新拍摄图片的下标；如删除了3.jpg，将返回2
 * @param latestPhotoPos   最新拍摄图片的坐标
 */
void onDeletionConfirmed(int latestPhotoIndex, int[] latestPhotoPos);

/**
 * 检测图片进度更新回调
 *
 * @param leftCount 剩余要处理图片的数量
 */
void onDetectProgressUpdated(int leftCount);

/**
 * 商品检测并去重处理完成的回调
 *
 * @param mergeResult 检测并去重结果
 */
void onDetectedResultsMerged(MergeResult mergeResult);

/* 初始化 */
FuzzyModelProxy fuzzyModelStateListener = new FuzzyModelProxy.ModelStateListener() {
    @Override
    public void onInitialized(Exception exception) {
        if (exception != null) {
            // 模糊模型初始化失败
        } else {
            // 模糊模型初始化成功
        }
    }

    @Override
    public void onDestroyed() {
        // 模糊模型销毁回调
    }
};
FuzzyModelProxy fuzzyModelProxy = new FuzzyModelProxy(mContext, fuzzyModelStateListener);
fuzzyModelProxy.initModel();

/* 调用示例 */
if (fuzzyModelProxy.modelEngineActivate()) {
    Bitmap bitmap = bitmapFromSomewhere();
    fuzzyModelProxy.infer(bitmap, new FuzzyModelProxy.ModelInferListener() {
        @Override
        public void onCompleted(boolean fuzzy) {
            if (!fuzzy) {
                // 图像非模糊
            } else {
                // 图像模糊
            }
        }
      
        @Override
        public void onException(Exception exception) {
            // 图像检测失败
        }
    }
} else {
    // 模糊图像推理引擎异常
}

/* 销毁 */                      
if (fuzzyModelProxy != null) {
    fuzzyModelProxy.destroyModelEngine();
    fuzzyModelStateListener = null;
}

/**
 * 设置最低iou置信度，需在init()后调用
 *
 * @param threshold 在0-1范围内有效
 */
public void setMinIouThreshold(float threshold);

/**
 * 设置最高iou置信度，需在init()后调用
 *
 * @param threshold 在0-1范围内有效
 */
public void setMaxIouThreshold(float threshold);

/**
 * 设置NMS置信度，需在init()后调用
 *
 * @param threshold 在0-1范围内有效
 */
public void setNmsIouThreshold(float threshold);

/**
 * 设置商品检测API最大重试次数
 *
 * @param maxRetryTimes 最大重试次数，<=0无效
 */
public void setMaxRetryTimes(int maxRetryTimes);

/**
 * 获取实例
 * @param appKey 网页上的应用的appkey
 * @param secretKey 网页上的应用的appSecret
 */
public static DetectionDoorAPI getInstance(String appKey, String secretKey);

/**
 * 初始化API
 * 建议传参getApplicationContext
 * 初始化（文件夹/定位）
 */
public void init(Context context);

// 注册门脸文字识别监听
public void registerListener(DoorAPIListener listener);

public interface DoorAPIListener {
    /**
     * 识别成功, 返回门脸文字识别结果
     * @param responseJson
     */
    void onDetectSuccess(String responseJson);
    /**
     * 识别异常
     * @param Exception e
     */
    void onException(Exception e);
}

// 销毁监听
public void unRegisterListener();

/**
 * 开始门脸文字识别
 * @param bitmap
 */
public void detectDoorImage(Bitmap bitmap);

// 释放资源
public void destroy();

ndk {
    abiFilters "arm64-v8a", "armeabi-v7a"
}

package com.baidu.ai.easydl.montage.page.photo;

public interface IPhotoParam {

    /**
     * 两张图片的hash算法
     */
    String IMAGE_COMPARE_HASH_METHOD = "pHash"; // pHash,dHash,ahash

    /**
     * 两张图片的hash比较值
     */
    float IMAGE_COMPARE_HASH_CONFIDENCE_THRESHOLD = 0.75f;

    /**
     * 相机的Sensor的旋转误差值， 取值为0-180，大于180表示忽略
     */
    int SENSOR_ORIENTATION_EVENT_DELTA = 20;

    /**
     * 传感器的SensorY的旋转误差值， 取值为0-180，大于180表示忽略
     */
    double SENSOR_ORIENTATION_SENSOR_Y_DELTA = Math.PI / 6;

    /**
     * 拍照建议的最低亮度值
     */
    double SENSOR_LIGHT_LUMEN_MIN = 100;

    /**
     * 拍照建议的最高亮度值
     */
    double SENSOR_LIGHT_LUMEN_MAX = 500;
    /**
     * 40%图片的透明度
     */
    float IMAGE_SLIDE_TRANSPARENT_ALPHA = 0.5f;

    /**
     * 每行货架最多的照片数量，服务端支持最大60
     */
    int SLOT_MAX_PHOTO_NUM = 60;

    // 下面的参数，请不要修改
    float IMAGE_SLIDE_CROP_RATIO = 0.4f;

    boolean IMAGE_COMPARE_HASH_DEBUG_SAVE_IMAGES = false;

}

package com.baidu.ai.utils;

public class CheckImageConfig {
    /**
     * 是否开启防窜拍
     * 默认开启
     */
   private volatile boolean pirateImageCheck = true;
   
   public void setPirateImageCheck(boolean pirateImageCheck) {
        this.pirateImageCheck = pirateImageCheck;
   }

   public boolean getPirateImageCheck() {
        return pirateImageCheck;
   }
}