#pragma once
#include "Pass_management.h"
#include "extravasation_detect.h"
#include "raw_image_class.h"
#include <stdio.h>
void OutputName(char* Bone, char* Ev, char* PreEv, char* Res, int casenum) {

	sprintf_s(Bone, 256, DIR CASENUM OUTNAME THREBON RAW, casenum, casenum);
	sprintf_s(Ev, 256, DIR CASENUM OUTNAME NAME_DOUBLE EVA RAW, casenum, casenum);
	sprintf_s(PreEv, 256, DIR CASENUM OUTNAME NAME_DOUBLE PREEVA RAW, casenum, casenum);
	sprintf_s(Res, 256, DIR CASENUM OUTNAME NAME_DOUBLE RES RAW, casenum, casenum);

}


void EvansDetect(Raw_image<short>& ct, array3<uchar>& evans, array3<uchar>& bone, int size1, int size2) {
	Raw_image<short> CTHEAD;
	Raw_image<short> CTLOWER;
	Raw_image<short> CTUPPER;

	CTHEAD.data.Depth = size1;
	CTHEAD.data.VOXELS = CTHEAD.data.IMAGESIZE * size1;
	CTHEAD.image = new short[CTHEAD.data.VOXELS];

	CTUPPER.data.Depth = size2 - size1;
	CTUPPER.data.VOXELS = CTUPPER.data.IMAGESIZE * CTUPPER.data.Depth;
	CTUPPER.image = new short[CTUPPER.data.VOXELS];

	CTLOWER.data.Depth = ct.data.Depth - size2;
	CTLOWER.data.VOXELS = CTLOWER.data.IMAGESIZE * CTLOWER.data.Depth;
	CTLOWER.image = new short[CTLOWER.data.VOXELS];

	for (int i = 0; i < ct.data.VOXELS; i++) {
		if (i < ct.data.IMAGESIZE * size1) {
			CTHEAD.image[i] = ct.image[i];
		}
		else if (i < ct.data.IMAGESIZE * size2) {
			CTUPPER.image[i - (ct.data.IMAGESIZE * size1)] = ct.image[i];
		}
		else {
			CTLOWER.image[i - (ct.data.IMAGESIZE * size2)] = ct.image[i];
		}
	}

	int thre = 350;
	if (size2 != 0) {
		thre = Extravasation_detect::Adaptive_Threshold(CTUPPER);
		printf("thre:%d\n", thre);
	}

	array3<uchar> BoneH, BoneU, BoneL;
	array3<uchar> EvansH, EvansL, EvansU;

	if (CTHEAD.data.Depth != 0) {
		auto th1 = std::thread([&BoneH, &CTHEAD,&EvansH, thre]
			{
				switch (BE)
				{
				case OLD:
					BoneH =Extravasation_detect::Old_BoneExtractMethod(CTHEAD,Extravasation_detect::HEAD);
					break;
				case WATER:
					BoneH =Extravasation_detect::Bone_Extract(CTHEAD,Extravasation_detect::HEAD);
					break;
				case ADAPTIVE:
					BoneH =Extravasation_detect::Bone_Extract(CTHEAD,Extravasation_detect::HEAD,thre);
					break;
				default:
					break;
				}

				EvansH =Extravasation_detect::double_thresholding(CTHEAD, BoneH, Extravasation_detect::HEAD);
			});

		auto th2 = std::thread([&BoneU, &CTUPPER, &EvansU, thre]
			{
				switch (BE)
				{
				case OLD:
					BoneU =Extravasation_detect::Old_BoneExtractMethod(CTUPPER,Extravasation_detect::UPPER);
					break;
				case WATER:
					BoneU =Extravasation_detect::Bone_Extract(CTUPPER, Extravasation_detect::UPPER);
					break;
				case ADAPTIVE:
					BoneU =Extravasation_detect::Bone_Extract(CTUPPER,Extravasation_detect::UPPER,thre);
					break;
				default:
					break;
				}



				EvansU =Extravasation_detect::double_thresholding(CTUPPER, BoneU,Extravasation_detect::UPPER);
			});

		auto th3 = std::thread([&BoneL, &CTLOWER,&EvansL, thre]
			{
				switch (BE)
				{
				case OLD:
					BoneL =Extravasation_detect::Old_BoneExtractMethod(CTLOWER,Extravasation_detect::LOWER);
					break;
				case WATER:
					BoneL =Extravasation_detect::Bone_Extract(CTLOWER,Extravasation_detect::LOWER);
					break;
				case ADAPTIVE:
					BoneL =Extravasation_detect::Bone_Extract(CTLOWER, Extravasation_detect::LOWER,thre);
					break;
				default:
					break;
				}

				EvansL =Extravasation_detect::double_thresholding(CTLOWER, BoneL,Extravasation_detect::LOWER);
			});

		th1.join();
		th2.join();
		th3.join();

		array3<uchar> tmp = Extravasation_detect::ArrayLink(BoneH, BoneU);
		bone = Extravasation_detect::ArrayLink(tmp, BoneL);

		array3<uchar> tmpE = Extravasation_detect::ArrayLink(EvansH, EvansU);
		evans = Extravasation_detect::ArrayLink(tmpE, EvansL);

		BoneH.clear();
		BoneU.clear();
		BoneL.clear();

		EvansH.clear();
		EvansU.clear();
		EvansL.clear();

	}
	else if (CTUPPER.data.Depth != 0) {

		auto th2 = std::thread([&BoneU, &CTUPPER, &EvansU, thre]
			{
				switch (BE)
				{
				case OLD:
					BoneU =Extravasation_detect::Old_BoneExtractMethod(CTUPPER,Extravasation_detect::UPPER);
					break;
				case WATER:
					BoneU =Extravasation_detect::Bone_Extract(CTUPPER,Extravasation_detect::UPPER);
					break;
				case ADAPTIVE:
					BoneU =Extravasation_detect::Bone_Extract(CTUPPER,Extravasation_detect::UPPER,thre);
					break;
				default:
					break;
				}
				EvansU =Extravasation_detect::double_thresholding(CTUPPER, BoneU,Extravasation_detect::UPPER);
			});

		auto th3 = std::thread([&BoneL, &CTLOWER,&EvansL, thre]
			{
				switch (BE)
				{
				case OLD:
					BoneL =Extravasation_detect::Old_BoneExtractMethod(CTLOWER,Extravasation_detect::LOWER);
					break;
				case WATER:
					BoneL =Extravasation_detect::Bone_Extract(CTLOWER,Extravasation_detect::LOWER);
					break;
				case ADAPTIVE:
					BoneL =Extravasation_detect::Bone_Extract(CTLOWER,Extravasation_detect::LOWER,thre);
					break;
				default:
					break;
				}
				EvansL =Extravasation_detect::double_thresholding(CTLOWER, BoneL,Extravasation_detect::LOWER);
			});

		th2.join();
		th3.join();

		bone = Extravasation_detect::ArrayLink(BoneU, BoneL);
		evans = Extravasation_detect::ArrayLink(EvansU, EvansL);

		BoneU.clear();
		BoneL.clear();
		EvansU.clear();
		EvansL.clear();
	}
	else {
		auto th3 = std::thread([&BoneL, &CTLOWER,&EvansL]
			{
				switch (BE)
				{
				case OLD:
					BoneL =Extravasation_detect::Old_BoneExtractMethod(CTLOWER,Extravasation_detect::LOWER);
					break;
				case WATER:
					BoneL =Extravasation_detect::Bone_Extract(CTLOWER,Extravasation_detect::LOWER);
					break;
				case ADAPTIVE:
					BoneL =Extravasation_detect::Bone_Extract(CTLOWER,Extravasation_detect::LOWER);
					break;
				default:
					break;
				}
				EvansL =Extravasation_detect::double_thresholding(CTLOWER, BoneL,Extravasation_detect::LOWER);
			});

		th3.join();

		bone = BoneL;
		evans = EvansL;
		BoneL.clear();
		EvansL.clear();

	}

	delete[] CTHEAD.image;
	delete[] CTUPPER.image;
	delete[] CTLOWER.image;
}