#include <stdio.h>
#include <future>
#include <iostream>
#include "raw_image_class.h"
#include "Pass_management.h"
#include <filesystem>
#include <direct.h>
#include "slice_predict.h"
#include "function.h"
#include "Feature_extraction.h"
#define Leng 64
#define USE_MODEL true
enum { RTREE, SVM };
//using namespace cv;
using namespace std;
int main(int argc, char* argv[]) {
int mode_select;
printf("検出モード:1 領域特徴量抽出モード:2 学習モード:3 FROC解析モード:4 BoneSegmentation:5");
scanf("%d", &mode_select);
if (mode_select == 1) {
int startcase;
printf("開始症例:");
scanf("%d", &startcase);
int endcase;
printf("終了:");
scanf("%d", &endcase);
cv::Mat RegionInfo;
auto AStart = std::chrono::steady_clock::now();
double EvaluationTime = 0;
FILE* fpOut;
FILE* fpOutP;
fopen_s(&fpOut, DIR DOUBLEOUT OUTNAME CSV, "w");
fopen_s(&fpOutP, DIR DOUBLEPRE OUTNAME CSV, "w");
if (fpOut == NULL) {
printf("ファイルが開けません\n");
getchar();
}
fprintf(fpOut, "症例番号,候補領域数,出血部位数,頭部,上半身,下半身,TP数,FP数,頭部,上半身,下半身,未検出領域数,頭部,上半身,下半身,検出時間(s),スライス数,\n");
fprintf(fpOutP, "症例番号,候補領域数,出血部位数,頭部,上半身,下半身,TP数,FP数,頭部,上半身,下半身,未検出領域数,頭部,上半身,下半身,検出時間(s),スライス数,\n");
//cv::Ptr<cv::ml::RTrees> r_tree = cv::ml::RTrees::load("D:\\YL\\Data\\BleedingData\\Ktest\\rtree_model.xml");
cv::Ptr<cv::ml::RTrees> r_tree = cv::ml::RTrees::load(DIR MODEL XML);
cv::dnn::Net net = cv::dnn::readNet(DIR CLASS);
cv::dnn::Net snet = cv::dnn::readNet(DIR SHOULDER);
cv::dnn::Net lnet = cv::dnn::readNet(DIR WAIST);
printf(DIR WAIST);
bool Calib = false;
for (int i = startcase; i < endcase; i++) {
//出力先の設定
char Bon[256];
char EV[256];
char PRE[256];
char RE[256];
OutputName(Bon, EV, PRE, RE, i);
char Name[256];
sprintf_s(Name, 256, DIR CTI RAW, i, i);
Raw_image<short> ct(Name);
char MaskName[256];
sprintf_s(MaskName, 256, DIR MAK RAW, i, i);
Raw_image<uchar> mask(MaskName);
printf("Detection start");
if (!ct.empty() && !mask.empty()) {
printf("症例:%d\n", i);
for (int sli = 0; sli < mask.data.VOXELS; sli++) {
if (mask.image[sli] != 0)
mask.image[sli] = 255;
else
mask.image[sli] = 0;
}
FILE* fp;
char NaSIZE[256];
sprintf_s(NaSIZE, 256, DIR SIZEFILE CSV, i, i);
fopen_s(&fp, NaSIZE, "r");
if (fp == NULL) {
printf("csv not exist---------------------------------------");
return(false);
}
int SIZE1 = 0;
int SIZE2 = 0;
fscanf(fp, "%d,%d,%f", &SIZE1, &SIZE2, &ct.data.reso);
fclose(fp);
printf("%d,%d,%f\n", SIZE1, SIZE2, ct.data.reso);
Slice_predict::predict(ct, SIZE1, SIZE2, net, snet, lnet);
printf("%d,%d,%f\n", SIZE1, SIZE2, ct.data.reso);
array3<uchar> DetectEvans;
array3<uchar> Bone;
auto start = std::chrono::steady_clock::now();
EvansDetect(ct, DetectEvans, Bone, SIZE1, SIZE2);
//計測終了
auto end = std::chrono::steady_clock::now();
double time = (double)std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
printf("検出時間%f\n", (time) / 1000);
array3<uchar> MArray(ct.data.Height, ct.data.Width, ct.data.Depth, ct.data.reso, ct.data.reso, ct.data.reso, 0);
for (int sli = 0; sli < ct.data.VOXELS; sli++)
MArray[sli] = mask.image[sli];
//結果のラベリング
array3<unsigned int> Label;
size_t ResCount = mist::labeling6(DetectEvans, Label);
auto evastart = std::chrono::steady_clock::now();
Extravasation_detect::Result Res = Extravasation_detect::Evaluation(Label, ResCount, MArray, SIZE1, SIZE2);
Res.ToString(i);
auto evaend = std::chrono::steady_clock::now();
double evatime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(evaend - evastart).count();
printf("評価時間:%f\n", evatime / 1000);
EvaluationTime += evatime;
fprintf(fpOut, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%0.3f,%d\n", i, Res.region, Res.OriginalP,
Res.HEADP, Res.UPPERP, Res.LOWERP, Res.TP, Res.FP, Res.HFP, Res.UFP, Res.LFP, Res.MissCount,
Res.MissH, Res.MissU, Res.MissL, time / 1000, ct.data.Depth);
mist::write_raw(Bone, Bon);
mist::write_raw(DetectEvans, RE);
mist::write_raw(Res.Evalu_Array, EV);
if (USE_MODEL) {
auto prestart = std::chrono::steady_clock::now();
cv::Mat FestureMat = Feature_extraction::All_feature_exstract(ct, Label, ResCount, Leng);
array3<uchar> Pre = Feature_extraction::Predict(r_tree, Label, ResCount, FestureMat);
auto preend = std::chrono::steady_clock::now();
double pretime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(preend - prestart).count();
printf("検出時間%f\n", (time + pretime) / 1000);
//結果のラベリング
array3<unsigned int> PreLabel;
size_t PreCount = mist::labeling6(Pre, PreLabel);
evastart = std::chrono::steady_clock::now();
Extravasation_detect::Result PredictRes = Extravasation_detect::Evaluation(PreLabel, PreCount, MArray, SIZE1, SIZE2);
evaend = std::chrono::steady_clock::now();
evatime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(evaend - evastart).count();
printf("評価時間:%f\n", evatime / 1000);
EvaluationTime += evatime;
mist::write_raw(PredictRes.Evalu_Array, PRE);
PredictRes.ToString(i);
fprintf(fpOutP, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%0.3f,%d\n", i, PredictRes.region, PredictRes.OriginalP,
PredictRes.HEADP, PredictRes.UPPERP, PredictRes.LOWERP, PredictRes.TP, PredictRes.FP, PredictRes.HFP, PredictRes.UFP, PredictRes.LFP, PredictRes.MissCount,
PredictRes.MissH, PredictRes.MissU, PredictRes.MissL, (pretime + time) / 1000, ct.data.Depth);
}
delete[] ct.image;
delete[] mask.image;
printf("-----------------------------------------------------------------------------------------------------------------------------\n");
}
}
auto Aend = std::chrono::steady_clock::now();
double Atime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(Aend - AStart).count();
printf("合計時間:%f[s](うち評価時間%f[s])", Atime / 1000, EvaluationTime / 1000);
fclose(fpOut);
fclose(fpOutP);
}
else if (mode_select == 2) {
printf("領域特徴量抽出開始...\n");
auto AStart = std::chrono::steady_clock::now();
cv::Mat TrueSet;
cv::Mat DataSet;
cv::Mat TrueRegion;
bool Calib = false;
bool trueCalib = false;
int TP = 0;
int FP = 0;
int TTP = 0;
int MTP = 0;
for (int i = 0; i < 109; i++) {
char Name[256];
sprintf_s(Name, 256, DIR CTI RAW, i, i);
Raw_image<short> ct(Name);
char MaskName[256];
sprintf_s(MaskName, 256, DIR MAK RAW, i, i);
Raw_image<uchar> mask(MaskName);
if (!ct.empty() && !mask.empty()) {
for (int i = 0; i < ct.data.VOXELS; i++) {
if (mask.image[i] != 0)
mask.image[i] = 255;
else
mask.image[i] = 0;
}
printf("症例%d...\n", i);
array3<uchar> MArray(ct.data.Height, ct.data.Width, ct.data.Depth, 0.5, 0.5, 0.5, 0);
for (int i = 0; i < ct.data.VOXELS; i++) {
MArray[i] = mask.image[i];
}
array3<unsigned int> MaskLabel;
size_t TrueCount = mist::labeling6(MArray, MaskLabel);
auto TruePoint = std::vector<Extravasation_detect::LabelData>(TrueCount + 1);
for (int i = 0; i < MArray.depth(); i++)
for (int j = 0; j < MArray.height(); j++)
for (int x = 0; x < MArray.width(); x++) {
int point = i * MArray.width() * MArray.height() + j * MArray.width() + x;
if (MaskLabel[point] != 0) {
TruePoint[MaskLabel[point]].Area++;
}
}
for (int i = 0; i < MArray.size(); i++) {
if (TruePoint[MaskLabel[i]].Area < 20) {
MArray[i] = 0;
}
}
MaskLabel.clear();
array3<uchar> TrueHE = Feature_extraction::Histogram_equalization(ct, Leng);
cv::Mat TL;
for (int i = -1; i <= 1; i++) {
array3<uchar> cMarray(ct.data.Height, ct.data.Width, ct.data.Depth, 0.5, 0.5, 0.5, 0);
for (int j = 0; j < MArray.size(); j++) {
cMarray[j] = MArray[j];
}
if (i < 0) {
mist::erosion(cMarray, -1 * i, 0);
printf("Erosion...");
}
if (i > 0) {
mist::dilation(cMarray, i, 0);
printf("Dilation...");
}
array3<unsigned int> Label;
auto ResCount = mist::labeling6(cMarray, Label);
if (ResCount > 0) {
cv::Mat TFesture = Feature_extraction::All_feature_exstract(ct, Label, ResCount, Leng);
TL = Feature_extraction::LabelMat(TFesture, 1);
if (!Calib) {
DataSet = TL.clone();
TrueRegion = TL.clone();
Calib = true;
}
else {
DataSet = Feature_extraction::Addsample(DataSet, TL);
TrueRegion = Feature_extraction::Addsample(TrueRegion, TL);
}
printf("%d,", DataSet.rows);
MTP += TL.rows;
}
}
printf("row:%d\n", MTP);
char ResultName[256];
sprintf_s(ResultName, 256, DIR CASENUM "DOUBLEFeature%d" RAW, i, i);
Raw_image<uchar> Resa(ResultName);
if (!Resa.empty()) {
array3<uchar> RFArray(ct.data.Height, ct.data.Width, ct.data.Depth, 0.5, 0.5, 0.5, 0);
array3<uchar> RTArray(ct.data.Height, ct.data.Width, ct.data.Depth, 0.5, 0.5, 0.5, 0);
for (int i = 0; i < ct.data.VOXELS; i++) {
if (Resa.image[i] > 10) {
if (Resa.image[i] == 255) {
RFArray[i] = 255;
}
else {
RTArray[i] = 255;
}
}
else {
RFArray[i] = 0;
RTArray[i] = 0;
}
}
cv::Mat RFL, RTL;
auto th2 = std::thread([&ct, &RFArray, &TrueHE, &RFL] {
array3<unsigned int> Label;
auto ResCount = mist::labeling6(RFArray, Label);
cv::Mat FalseFesture = Feature_extraction::All_feature_exstract(ct, Label, ResCount, Leng);
RFL = Feature_extraction::LabelMat(FalseFesture, 0); });
auto th3 = std::thread([&ct, &RTArray, &TrueHE, &RTL] {
array3<unsigned int> Label;
auto ResCount = mist::labeling6(RTArray, Label);
if (ResCount > 0) {
cv::Mat TFesture = Feature_extraction::All_feature_exstract(ct, Label, ResCount, Leng);
RTL = Feature_extraction::LabelMat(TFesture, 1);
}});
th2.join();
th3.join();
if (RFL.rows > 0) {
DataSet = Feature_extraction::Addsample(DataSet, RFL);
}
if (RTL.rows > 0) {
DataSet = Feature_extraction::Addsample(DataSet, RTL);
}
if (!trueCalib) {
TrueSet = Feature_extraction::Addsample(RFL, RTL);
trueCalib = true;
}
else {
if (RFL.rows > 0) {
TrueSet = Feature_extraction::Addsample(TrueSet, RFL);
}
if (RTL.rows > 0) {
TrueSet = Feature_extraction::Addsample(TrueSet, RTL);
}
}
TP += RTL.rows;
FP += RFL.rows;
TTP += TL.rows;
printf("症例%d解析完了 出血領域数:%d TP:%d FP:%d\n", i, TL.rows, RTL.rows, RFL.rows);
printf("Dataset col:%d rows:%d\n", DataSet.cols, DataSet.rows);
Calib = true;
trueCalib = true;
delete[] Resa.image;
}
delete[] ct.image;
delete[] mask.image;
printf("-----------------------------------------------------------------------------------\n");
}
}
auto Aend = std::chrono::steady_clock::now();
double Atime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(Aend - AStart).count();
printf("合計時間:%f[s]", Atime / 1000);
printf("TP:%d FP:%d\n", TP, FP);
printf("TrueSet：%d\n", TrueSet.rows);
printf("TrueRegion：%d\n", TrueRegion.rows);
cv::Mat Re = Feature_extraction::Feature_Cut(DataSet, true, 1);
char csvfile[256];
sprintf_s(csvfile, 256, DIR DST CSV);
Feature_extraction::writeCSV(csvfile, Re);
char Rcsv[256];
sprintf_s(Rcsv, 256, DIR RCSV CSV);
Feature_extraction::writeCSV(Rcsv, TrueSet);
}
else if (mode_select == 3) {
int random;
printf("ランダムフォレスト:1 SVM:2");
scanf("%d", &random);
if (random == 1) {
printf("ランダムフォレスト学習開始\n");
printf(DIR DST CSV);
cv::Ptr<cv::ml::TrainData> data = cv::ml::TrainData::loadFromCSV(DIR DST CSV, 0, 0, -1);
cv::Ptr<cv::ml::RTrees> r_tree = cv::ml::RTrees::create();
printf("Traning DataSet:%s\n", DST CSV);
//data->setTrainTestSplitRatio(0.95, true);
r_tree->setMaxDepth(23);
r_tree->setMinSampleCount(2);
r_tree->setCalculateVarImportance(true);
r_tree->setTermCriteria(cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 1000, 0.001));
r_tree->train(data);
printf("train error: %f\n", r_tree->calcError(data, false, cv::noArray()));
/* printf("test error: %f\n\n", r_tree->calcError(data, true, noArray()));*/
cv::Mat s = r_tree->getVarImportance();
printf("row:%d,col:%d\n", s.rows, s.cols);
for (int i = 0; i < s.rows; i++) {
for (int k = 0; k < s.cols; k++) {
printf("%f", s.at<float>(i, k));
if (k == s.cols - 1) {
printf("\n");
}
else
printf(",");
}
}
r_tree->save(DIR MODEL XML);
}
else if (random == 2) {
cv::Ptr<cv::ml::TrainData> data = cv::ml::TrainData::loadFromCSV(DIR DST CSV, 0, 0, -1);
cv::Ptr<cv::ml::TrainData> testdata = cv::ml::TrainData::loadFromCSV(DIR RCSV CSV, 0, 0, -1);
//data->setTrainTestSplitRatio(0.90, true);
printf("Traning DataSet:%s\n", DST CSV);
int adaC;
double adaGanma;
double maxScore = 100;
for (int C = 1; C < 10; C++)
for (double G = 1e-5; G < 10000; G *= 10) {
cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
svm->setType(cv::ml::SVM::C_SVC);
svm->setKernel(cv::ml::SVM::RBF);
svm->setC(C);
svm->setGamma(G);
svm->setTermCriteria(cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 1000, 0.001));
svm->train(data);
float score = svm->calcError(testdata, false, cv::noArray());
//printf("Score:%f C:%f Gamma:%f\n", score, C, G);
if (maxScore > score) {
printf("Updata....Score:%f C:%d Gamma:%f\n", score, C, G);
maxScore = score;
adaC = C;
adaGanma = G;
}
}
printf("final....Score:%f C:%d Gamma:%f\n", maxScore, adaC, adaGanma);
cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
svm->setType(cv::ml::SVM::C_SVC);
svm->setKernel(cv::ml::SVM::RBF);
svm->setC(adaC);
svm->setGamma(adaGanma);
svm->setTermCriteria(cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 1000, 0.001));
svm->train(data);
svm->save(DIR "\\SVMIso" XML);
}
printf("\a\a\a");
printf("学習完了\n");
}
else if (mode_select == 4) {
printf("Rtree:0 SVM:1\n");
int mode;
scanf("%d", &mode);
if (mode == RTREE) {
cv::Ptr<cv::ml::RTrees> r_tree = cv::ml::RTrees::load(DIR MODEL XML);
printf("model_name:%s\n", MODEL XML);
printf("ROCCSV:%s\n", RCSV CSV);
char name[256];
sprintf_s(name, 256, DIR RCSV CSV);
Feature_extraction::CSVData s = Feature_extraction::readCSV(name);
float* pre = new float[s.Labels.rows];
FILE* fpOut;
fopen_s(&fpOut, DIR FROC CSV, "w");
fprintf(fpOut, "Rate,TP,TN,FP,FN,感度,平均FP\n");
for (float Rate = 0.6; Rate > 0; Rate -= (float)0.01) {
int TP = 0;
int TN = 0;
int FP = 0;
int FN = 0;
for (int i = 0; i < s.Labels.rows; i++) {
cv::Mat sam = s.samples.row(i).clone();
pre[i] = r_tree->predict(sam, cv::noArray(), cv::ml::StatModel::RAW_OUTPUT);
pre[i] = pre[i] / 1000;
if (pre[i] > Rate)
pre[i] = 1;
else
pre[i] = 0;
if (pre[i] == 1) {
if (pre[i] == s.Labels.at<float>(i, 0)) {
TP++;
}
else {
FP++;
}
}
else {
if (pre[i] == s.Labels.at<float>(i, 0)) {
FN++;
}
else {
TN++;
}
}
}
printf("Rate:%f TP:%d TN:%d FP:%d FN:%d 感度:%f 平均FP:%f\n", Rate, TP, TN, FP, FN, (float)TP / (float)(TP + TN), (float)FP / 28);
fprintf(fpOut, "%f,%d,%d,%d,%d,%f,%f\n", Rate, TP, TN, FP, FN, (float)TP / (float)(TP + TN), (float)FP / 35);
}
fclose(fpOut);
fopen_s(&fpOut, DIR ROC TXT, "w");
for (int i = 0; i < s.Labels.rows; i++) {
cv::Mat sam = s.samples.row(i).clone();
pre[i] = r_tree->predict(sam, cv::noArray(), cv::ml::StatModel::RAW_OUTPUT);
pre[i] = pre[i] / 1000;
fprintf(fpOut, "%f,%d\n", pre[i], (int)s.Labels.at<float>(i, 0));
}
fclose(fpOut);
}
else if (mode == SVM) {
cv::Ptr<cv::ml::SVM> r_tree = cv::ml::SVM::load(DIR "\\SVMIso" XML);
printf("model_name:%s\n", "\\SVMIso" XML);
printf("ROCCSV:%s\n", RCSV CSV);
char name[256];
sprintf_s(name, 256, DIR RCSV CSV);
Feature_extraction::CSVData s = Feature_extraction::readCSV(name);
double* pre = new double[s.Labels.rows];
FILE* fpOut;
fopen_s(&fpOut, DIR FROC CSV, "w");
fprintf(fpOut, "Rate,TP,TN,FP,FN,感度,平均FP\n");
for (float j = 0; j <= 1; j += 0.001) {
int TP = 0;
int TN = 0;
int FP = 0;
int FN = 0;
for (int i = 0; i < s.Labels.rows; i++) {
cv::Mat sam = s.samples.row(i).clone();
pre[i] = r_tree->predict(sam);
//printf("%f\n", pre[i]);
if (pre[i] <= j) {
if (1 == s.Labels.at<float>(i, 0)) {
TP++;
}
else {
FP++;
}
}
else {
if (0 == s.Labels.at<float>(i, 0)) {
FN++;
}
else {
TN++;
}
}
}
printf("%f TP:%d TN:%d FP:%d FN:%d 感度:%f 平均FP:%f\n", j, TP, TN, FP, FN, (float)TP / (float)(TP + TN), (float)FP / 35);
fprintf(fpOut, "%f,%d,%d,%d,%d,%f,%f\n", j, TP, TN, FP, FN, (float)TP / (float)(TP + TN), (float)FP / 35);
}
fclose(fpOut);
fopen_s(&fpOut, DIR ROC TXT, "w");
for (int i = 0; i < s.Labels.rows; i++) {
cv::Mat sam = s.samples.row(i).clone();
pre[i] = r_tree->predict(sam, cv::noArray());
fprintf(fpOut, "%f,%d\n", pre[i], (int)s.Labels.at<float>(i, 0));
}
fclose(fpOut);
}
}
else if (mode_select == 5)
{
int startcase;
printf("開始症例:");
scanf("%d", &startcase);
int endcase;
printf("終了:");
scanf("%d", &endcase);
cv::Mat RegionInfo;
cv::Ptr<cv::ml::RTrees> r_tree = cv::ml::RTrees::load(DIR MODEL XML);
cv::dnn::Net net = cv::dnn::readNet(DIR CLASS);
cv::dnn::Net snet = cv::dnn::readNet(DIR SHOULDER);
cv::dnn::Net lnet = cv::dnn::readNet(DIR WAIST);
auto AStart = std::chrono::steady_clock::now();
//double EvaluationTime = 0;
bool Calib = false;
for (int i = startcase; i < endcase; i++) {
//出力先の設定
char Bon[256];
char EV[256];
char PRE[256];
char RE[256];
OutputName(Bon, EV, PRE, RE, i);
char Name[256];
sprintf_s(Name, 256, DIR CTI RAW, i, i);
Raw_image<short> ct(Name);
/*char MaskName[256];
sprintf_s(MaskName, 256, DIR MAK RAW, i, i);
Raw_image<uchar> mask(MaskName);*/
printf("Segmentation start");
//if (!ct.empty() && !mask.empty()) {
if (!ct.empty()) {
printf("症例:%d\n", i);
/*for (int sli = 0; sli < mask.data.VOXELS; sli++) {
if (mask.image[sli] != 0)
mask.image[sli] = 255;
else
mask.image[sli] = 0;
}*/
//FILE* fp;
//char NaSIZE[256];
//sprintf_s(NaSIZE, 256, DIR SIZEFILE CSV, i, i);
//fopen_s(&fp, NaSIZE, "r");
//if (fp == NULL) {
// printf("csv not exist---------------------------------------");
// return(false);
//}
int SIZE1 = 0;
int SIZE2 = 0;
/*fscanf(fp, "%d,%d,%f", &SIZE1, &SIZE2, &ct.data.reso);
fclose(fp);
printf("%d,%d,%f\n", SIZE1, SIZE2, ct.data.reso);*/
Slice_predict::predict(ct, SIZE1, SIZE2, net, snet, lnet);
//printf("%d,%d,%f\n", SIZE1, SIZE2, ct.data.reso);
array3<uchar> DetectEvans;
array3<uchar> Bone;
auto start = std::chrono::steady_clock::now();
EvansDetect(ct, DetectEvans, Bone, SIZE1, SIZE2);
//計測終了
/*auto end = std::chrono::steady_clock::now();
double time = (double)std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
printf("検出時間%f\n", (time) / 1000);
array3<uchar> MArray(ct.data.Height, ct.data.Width, ct.data.Depth, ct.data.reso, ct.data.reso, ct.data.reso, 0);
for (int sli = 0; sli < ct.data.VOXELS; sli++)
MArray[sli] = mask.image[sli];*/
////結果のラベリング
//array3<unsigned int> Label;
//size_t ResCount = mist::labeling6(DetectEvans, Label);
//auto evastart = std::chrono::steady_clock::now();
//Extravasation_detect::Result Res = Extravasation_detect::Evaluation(Label, ResCount, MArray, SIZE1, SIZE2);
//Res.ToString(i);
//auto evaend = std::chrono::steady_clock::now();
//double evatime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(evaend - evastart).count();
//printf("評価時間:%f\n", evatime / 1000);
//EvaluationTime += evatime;
/*fprintf(fpOut, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%0.3f,%d\n", i, Res.region, Res.OriginalP,
Res.HEADP, Res.UPPERP, Res.LOWERP, Res.TP, Res.FP, Res.HFP, Res.UFP, Res.LFP, Res.MissCount,
Res.MissH, Res.MissU, Res.MissL, time / 1000, ct.data.Depth);*/
mist::write_raw(Bone, Bon);
/*mist::write_raw(DetectEvans, RE);
mist::write_raw(Res.Evalu_Array, EV);*/
//if (USE_MODEL) {
// auto prestart = std::chrono::steady_clock::now();
// cv::Mat FestureMat = Feature_extraction::All_feature_exstract(ct, Label, ResCount, Leng);
// array3<uchar> Pre = Feature_extraction::Predict(r_tree, Label, ResCount, FestureMat);
// auto preend = std::chrono::steady_clock::now();
// double pretime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(preend - prestart).count();
// printf("検出時間%f\n", (time + pretime) / 1000);
// //結果のラベリング
// array3<unsigned int> PreLabel;
// size_t PreCount = mist::labeling6(Pre, PreLabel);
// evastart = std::chrono::steady_clock::now();
// Extravasation_detect::Result PredictRes = Extravasation_detect::Evaluation(PreLabel, PreCount, MArray, SIZE1, SIZE2);
// evaend = std::chrono::steady_clock::now();
// evatime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(evaend - evastart).count();
// printf("評価時間:%f\n", evatime / 1000);
// EvaluationTime += evatime;
// mist::write_raw(PredictRes.Evalu_Array, PRE);
// PredictRes.ToString(i);
// /*fprintf(fpOutP, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%0.3f,%d\n", i, PredictRes.region, PredictRes.OriginalP,
// PredictRes.HEADP, PredictRes.UPPERP, PredictRes.LOWERP, PredictRes.TP, PredictRes.FP, PredictRes.HFP, PredictRes.UFP, PredictRes.LFP, PredictRes.MissCount,
// PredictRes.MissH, PredictRes.MissU, PredictRes.MissL, (pretime + time) / 1000, ct.data.Depth);*/
//}
delete[] ct.image;
/*delete[] mask.image;*/
printf("-----------------------------------------------------------------------------------------------------------------------------\n");
}
}
//auto Aend = std::chrono::steady_clock::now();
//double Atime = (double)std::chrono::duration_cast<std::chrono::milliseconds>(Aend - AStart).count();
//printf("合計時間:%f[s](うち評価時間%f[s])", Atime / 1000, EvaluationTime / 1000);
//fclose(fpOut);
//fclose(fpOutP);
}
printf("完了");
printf("\a");
getchar();
return(0);
}
