void processImage(V3DPluginCallback2 &callback, QWidget *parent, unsigned int rotateflag)
{
v3dhandle curwin = callback.currentImageWindow();
if (!curwin)
{
QMessageBox::information(0, "", "You don't have any image open in the main window.");
return;
}
Image4DSimple* image = callback.getImage(curwin);
if (!image)
{
QMessageBox::information(0, "", "The image pointer is invalid. Ensure your data is valid and try again!");
return;
}
unsigned char* data1d = image->getRawData();
V3DLONG szx = image->getXDim(), szy = image->getYDim(), szz = image->getZDim(), szc = image->getCDim();
// V3DLONG szchan = image->getTotalUnitNumberPerChannel(), szplane = image->getTotalUnitNumberPerPlane();
// V3DLONG N = image->getTotalBytes();
// V3DLONG i,j,k,c;
if (!data1d || szx<=0 || szy<=0 || szz<=0 || szc<=0)
{
throw("Your data to the plugin is invalid. Check the program.");
return;
}
ImagePixelType pixeltype = image->getDatatype();
V3DLONG in_sz[4];
in_sz[0]=szx; in_sz[1]=szy; in_sz[2]=szz; in_sz[3]=szc;
unsigned char* outimg=0;
rotateimage(data1d, in_sz, pixeltype, rotateflag, outimg);
// image->setData(outimg, szy, szx, szz, szc, image->getDatatype());
// display
Image4DSimple * new4DImage = new Image4DSimple();
switch(rotateflag)
{
case 1:
new4DImage->setData((unsigned char*)outimg, szy, szx, szz, szc, image->getDatatype());
break;
case 2:
new4DImage->setData((unsigned char*)outimg, szy, szx, szz, szc, image->getDatatype());
break;
case 3:
new4DImage->setData((unsigned char*)outimg, szx, szy, szz, szc, image->getDatatype());
break;
default:
break;
}
v3dhandle newwin = callback.newImageWindow();
callback.setImage(newwin, new4DImage);
callback.setImageName(newwin, title);
callback.updateImageWindow(newwin);
}
// show different datatype data in V3D
int datatype_converting(V3DPluginCallback2 &callback, QWidget *parent)
{
v3dhandleList win_list = callback.getImageWindowList();
if(win_list.size()<1)
{
v3d_msg("No image is open.");
return -1;
}
//
DTCDialog dialog(callback,parent);
if (dialog.exec()!=QDialog::Accepted) return -1;
dialog.update();
V3DLONG isub = dialog.isub;
V3DLONG dt = dialog.dt;
//
ImagePixelType cnvrt_dt;
if(dt==0)
{
cnvrt_dt = V3D_UINT8;
}
else if(dt==1)
{
cnvrt_dt = V3D_UINT16;
}
else if(dt==2)
{
cnvrt_dt = V3D_FLOAT32;
}
Image4DSimple* subject = callback.getImage(win_list[isub]);
if (!subject)
{
QMessageBox::information(0, title, QObject::tr("Image does not exist."));
return -1;
}
unsigned char* subject1d = subject->getRawData();
V3DLONG sx = subject->getXDim();
V3DLONG sy = subject->getYDim();
V3DLONG sz = subject->getZDim();
V3DLONG sc = subject->getCDim();
V3DLONG sz_sub = sx*sy*sz*sc;
ImagePixelType sub_dt = subject->getDatatype();
//Converting
if(cnvrt_dt == V3D_UINT8)
{
unsigned char * data1d = NULL;
try
{
data1d = new unsigned char [sz_sub];
}
catch(...)
{
printf("Error allocating memory. \n");
return -1;
}
//
if(sub_dt == V3D_UINT8)
{
converting<unsigned char, unsigned char>((unsigned char *)subject1d, data1d, sz_sub, cnvrt_dt);
}
else if(sub_dt == V3D_UINT16)
{
converting<unsigned short, unsigned char>((unsigned short *)subject1d, data1d, sz_sub, cnvrt_dt);
}
else if(sub_dt == V3D_FLOAT32)
{
converting<float, unsigned char>((float *)subject1d, data1d, sz_sub, cnvrt_dt);
}
//display
Image4DSimple p4DImage;
p4DImage.setData((unsigned char*)data1d, sx, sy, sz, sc, V3D_UINT8); //
v3dhandle newwin = callback.newImageWindow();
callback.setImage(newwin, &p4DImage);
callback.setImageName(newwin, "Converted Image");
callback.updateImageWindow(newwin);
}
else if(cnvrt_dt == V3D_UINT16)
{
unsigned short * data1d = NULL;
try
{
data1d = new unsigned short [sz_sub];
}
catch(...)
{
printf("Error allocating memory. \n");
return -1;
}
//
if(sub_dt == V3D_UINT8)
{
converting<unsigned char, unsigned short>((unsigned char *)subject1d, data1d, sz_sub, cnvrt_dt);
}
else if(sub_dt == V3D_UINT16)
{
converting<unsigned short, unsigned short>((unsigned short *)subject1d, data1d, sz_sub, cnvrt_dt);
}
else if(sub_dt == V3D_FLOAT32)
{
converting<float, unsigned short>((float *)subject1d, data1d, sz_sub, cnvrt_dt);
}
//display
Image4DSimple p4DImage;
p4DImage.setData((unsigned char*)data1d, sx, sy, sz, sc, V3D_UINT16); //
v3dhandle newwin = callback.newImageWindow();
callback.setImage(newwin, &p4DImage);
callback.setImageName(newwin, "Converted Image");
callback.updateImageWindow(newwin);
}
else if(cnvrt_dt == V3D_FLOAT32)
{
float * data1d = NULL;
try
{
data1d = new float [sz_sub];
}
catch(...)
{
printf("Error allocating memory. \n");
return -1;
}
//
if(sub_dt == V3D_UINT8)
{
converting<unsigned char, float>((unsigned char *)subject1d, data1d, sz_sub, cnvrt_dt);
}
else if(sub_dt == V3D_UINT16)
{
converting<unsigned short, float>((unsigned short *)subject1d, data1d, sz_sub, cnvrt_dt);
}
else if(sub_dt == V3D_FLOAT32)
{
converting<float, float>((float *)subject1d, data1d, sz_sub, cnvrt_dt);
}
//display
Image4DSimple p4DImage;
p4DImage.setData((unsigned char*)data1d, sx, sy, sz, sc, V3D_FLOAT32); //
v3dhandle newwin = callback.newImageWindow();
callback.setImage(newwin, &p4DImage);
callback.setImageName(newwin, "Converted Image");
callback.updateImageWindow(newwin);
}
else
{
printf("Currently this program only support UINT8, UINT16, and FLOAT32 data type.\n");
return -1;
}
//
return 0;
}
void imfilling(V3DPluginCallback &callback, QWidget *parent)
{
v3dhandleList win_list = callback.getImageWindowList();
if(win_list.size()<1)
{
QMessageBox::information(0, title, QObject::tr("No image is open."));
return;
}
ImFillDialog dialog(callback, parent);
if (dialog.exec()!=QDialog::Accepted)
return;
int start_t = clock(); // record time point
dialog.update();
int i1 = dialog.i1;
int ch = dialog.ch_rgb;
bool mean_thresh = dialog.mean_thresh;
int thresh, range;
if(mean_thresh)
{
thresh = dialog.thresh;
range = dialog.range;
}
//qDebug() << " test... " << thresh << range;
bool use_marker = true;
Image4DSimple* subject = callback.getImage(win_list[i1]);
ROIList pRoiList=callback.getROI(win_list[i1]);
QString m_InputFileName = callback.getImageName(win_list[i1]);
if (!subject)
{
QMessageBox::information(0, title, QObject::tr("No image is open."));
return;
}
if (subject->getDatatype()!=V3D_UINT8)
{
QMessageBox::information(0, title, QObject::tr("This demo program only supports 8-bit data. Your current image data type is not supported."));
return;
}
//also get the landmark from the subject
LandmarkList list_landmark_sub=callback.getLandmark(win_list[i1]);
if(list_landmark_sub.size()<1)
{
use_marker = false;
}
else
{
QMessageBox msgBox;
msgBox.setText("The marker has been choosen.");
msgBox.setInformativeText("Do you want to use your first marker as a seed to tell image background?");
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Ok);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Ok:
// Ok was clicked
break;
case QMessageBox::Cancel:
// Cancel was clicked
return;
break;
default:
// should never be reached
break;
}
}
unsigned char* pSbject = subject->getRawData();
long sz0 = subject->getXDim();
long sz1 = subject->getYDim();
long sz2 = subject->getZDim();
long sz3 = subject->getCDim();
long pagesz_sub = sz0*sz1*sz2;
//---------------------------------------------------------------------------------------------------------------------------------------------------
//finding the bounding box of ROI
bool vxy=true,vyz=true,vzx=true; // 3 2d-views
QRect b_xy = pRoiList.at(0).boundingRect();
QRect b_yz = pRoiList.at(1).boundingRect();
QRect b_zx = pRoiList.at(2).boundingRect();
if(b_xy.left()==-1 || b_xy.top()==-1 || b_xy.right()==-1 || b_xy.bottom()==-1)
vxy=false;
if(b_yz.left()==-1 || b_yz.top()==-1 || b_yz.right()==-1 || b_yz.bottom()==-1)
vyz=false;
if(b_zx.left()==-1 || b_zx.top()==-1 || b_zx.right()==-1 || b_zx.bottom()==-1)
vzx=false;
long bpos_x, bpos_y, bpos_z, bpos_c, epos_x, epos_y, epos_z, epos_c;
// 8 cases
if(vxy && vyz && vzx) // all 3 2d-views
{
bpos_x = qBound(long(0), long(qMax(b_xy.left(), b_zx.left())), sz0-1);
bpos_y = qBound(long(0), long(qMax(b_xy.top(), b_yz.top())), sz1-1);
bpos_z = qBound(long(0), long(qMax(b_yz.left(), b_zx.top())), sz2-1);
epos_x = qBound(long(0), long(qMin(b_xy.right(), b_zx.right())), sz0-1);
epos_y = qBound(long(0), long(qMin(b_xy.bottom(), b_yz.bottom())), sz1-1);
epos_z = qBound(long(0), long(qMin(b_yz.right(), b_zx.bottom())), sz2-1);
}
else if(!vxy && vyz && vzx) // 2 of 3
{
bpos_x = qBound(long(0), long(qMax(0, b_zx.left())), sz0-1);
bpos_y = qBound(long(0), long(qMax(0, b_yz.top())), sz1-1);
bpos_z = qBound(long(0), long(qMax(b_yz.left(), b_zx.top())), sz2-1);
epos_x = qBound(long(0), long(fmin(sz0-1, b_zx.right())), sz0-1);
epos_y = qBound(long(0), long(fmin(sz1-1, b_yz.bottom())), sz1-1);
epos_z = qBound(long(0), long(qMin(b_yz.right(), b_zx.bottom())), sz2-1);
}
else if(vxy && !vyz && vzx)
{
bpos_x = qBound(long(0), long(qMax(b_xy.left(), b_zx.left())), sz0-1);
bpos_y = qBound(long(0), long(qMax(b_xy.top(), 0)), sz1-1);
bpos_z = qBound(long(0), long(qMax(0, b_zx.top())), sz2-1);
epos_x = qBound(long(0), long(qMin(b_xy.right(), b_zx.right())), sz0-1);
epos_y = qBound(long(0), long(fmin(b_xy.bottom(), sz1-1)), sz1-1);
epos_z = qBound(long(0), long(fmin(sz2-1, b_zx.bottom())), sz2-1);
}
else if(vxy && vyz && !vzx)
{
bpos_x = qBound(long(0), long(qMax(b_xy.left(), 0)), sz0-1);
bpos_y = qBound(long(0), long(qMax(b_xy.top(), b_yz.top())), sz1-1);
bpos_z = qBound(long(0), long(qMax(b_yz.left(), 0)), sz2-1);
epos_x = qBound(long(0), long(fmin(b_xy.right(), sz0-1)), sz0-1);
epos_y = qBound(long(0), long(qMin(b_xy.bottom(), b_yz.bottom())), sz1-1);
epos_z = qBound(long(0), long(fmin(b_yz.right(), sz2-1)), sz2-1);
}
else if(vxy && !vyz && !vzx) // only 1 of 3
{
bpos_x = qBound(long(0), long(qMax(b_xy.left(), 0)), sz0-1);
bpos_y = qBound(long(0), long(qMax(b_xy.top(), 0)), sz1-1);
bpos_z = 0;
epos_x = qBound(long(0), long(fmin(b_xy.right(), sz0-1)), sz0-1);
epos_y = qBound(long(0), long(fmin(b_xy.bottom(), sz1-1)), sz1-1);
epos_z = sz2-1;
}
else if(!vxy && vyz && !vzx)
{
bpos_x = 0;
bpos_y = qBound(long(0), long(qMax(0, b_yz.top())), sz1-1);
bpos_z = qBound(long(0), long(qMax(b_yz.left(), 0)), sz2-1);
epos_x = sz0-1;
epos_y = qBound(long(0), long(fmin(sz1-1, b_yz.bottom())), sz1-1);
epos_z = qBound(long(0), long(fmin(b_yz.right(), sz2-1)), sz2-1);
}
else if(!vxy && !vyz && vzx)
{
bpos_x = qBound(long(0), long(qMax(0, b_zx.left())), sz0-1);
bpos_y = 0;
bpos_z = qBound(long(0), long(qMax(0, b_zx.top())), sz2-1);
epos_x = qBound(long(0), long(fmin(sz0-1, b_zx.right())), sz0-1);
epos_y = sz1-1;
epos_z = qBound(long(0), long(fmin(sz2-1, b_zx.bottom())), sz2-1);
}
else // 0
{
bpos_x = 0;
bpos_y = 0;
bpos_z = 0;
epos_x = sz0-1;
epos_y = sz1-1;
epos_z = sz2-1;
}
//qDebug("x %d y %d z %d x %d y %d z %d ",bpos_x,bpos_y,bpos_z,epos_x,epos_y,epos_z);
//ROI extraction
long sx = (epos_x-bpos_x)+1;
long sy = (epos_y-bpos_y)+1;
long sz = (epos_z-bpos_z)+1;
long sc = sz3; // 0,1,2
//choose the channel stack
long pagesz = sx*sy*sz;
double meanv=0;
long offset_sub = ch*pagesz_sub;
//------------------------------------------------------------------------------------------------------------------------------------
// scans time
int i_progress=0;
int num_progress = 4; // haw many scanning process
//
QProgressDialog progress("Filling hole...", "Abort Image Filling", 0, num_progress, parent);
progress.setWindowModality(Qt::WindowModal);
// first scan
progress.setValue(++i_progress);
unsigned char *data1d = new unsigned char [pagesz];
if (!data1d)
{
printf("Fail to allocate memory.\n");
return;
}
else
{
for(long k=bpos_z; k<=epos_z; k++)
{
long offset_z = k*sz0*sz1;
long offset_crop_z = (k-bpos_z)*sx*sy;
for(long j=bpos_y; j<=epos_y; j++)
{
long offset_y = j*sz0 + offset_z;
long offset_crop_y = (j-bpos_y)*sx + offset_crop_z;
for(long i=bpos_x; i<=epos_x; i++)
{
data1d[(i-bpos_x) + offset_crop_y] = pSbject[offset_sub + i+offset_y];
meanv += data1d[(i-bpos_x) + offset_crop_y];
}
}
}
}
meanv /= pagesz;
qDebug("mean value %lf", meanv);
//----------------------------------------------------------------------------------------------------------------------------------
// preprocess the landmarker
int seed_x, seed_y, seed_z;
unsigned char seed_val;
int range_val=3;
if(use_marker)
{
seed_x = list_landmark_sub[0].x -1; // notice 0-based and 1-based difference
seed_y = list_landmark_sub[0].y -1;
seed_z = list_landmark_sub[0].z -1;
seed_val = pSbject[seed_z*sz0*sz1 + seed_y*sz0 + seed_x + offset_sub];
}
else
{
if(mean_thresh)
{
seed_val = thresh;
range_val = range;
qDebug() << "seed value" << seed_val;
for(long k=bpos_z; k<=epos_z; k++)
{
long offset_crop_z = (k-bpos_z)*sx*sy;
for(long j=bpos_y; j<=epos_y; j++)
{
long offset_crop_y = (j-bpos_y)*sx + offset_crop_z;
for(long i=bpos_x; i<=epos_x; i++)
{
if(i==bpos_x || i==epos_x || j==bpos_y || j==epos_y || k==bpos_z || k==epos_z)
continue;
if(data1d[(i-bpos_x) + offset_crop_y] == seed_val)
{
seed_x = (i-bpos_x) ; seed_y = (j-bpos_y); seed_z = (k-bpos_z);
break;
}
}
}
}
}
else
{
seed_val = 0;
range_val = meanv;
qDebug() << "seed value" << seed_val;
if(seed_val<0) seed_val = 0;
for(long k=bpos_z; k<=epos_z; k++)
{
long offset_crop_z = (k-bpos_z)*sx*sy;
for(long j=bpos_y; j<=epos_y; j++)
{
long offset_crop_y = (j-bpos_y)*sx + offset_crop_z;
for(long i=bpos_x; i<=epos_x; i++)
{
if(i==bpos_x || i==epos_x || j==bpos_y || j==epos_y || k==bpos_z || k==epos_z)
continue;
if(data1d[(i-bpos_x) + offset_crop_y] == seed_val)
{
seed_x = (i-bpos_x) ; seed_y = (j-bpos_y); seed_z = (k-bpos_z);
break;
}
}
}
}
}
}
qDebug("x %d y %d z %d thresh %d range %d intensity %d", seed_x, seed_y, seed_z, seed_val, range_val, data1d[seed_z*sx*sy + seed_y*sx + seed_x]);
//----------------------------------------------------------------------------------------------------------------------------------
// de-alloc
//if (pSbject) {delete []pSbject; pSbject=0;} // image visualized in v3d now
// second scan
progress.setValue(++i_progress);
// 3D region growing
//----------------------------------------------------------------------------------------------------------------------------------
int end_preprocess = clock();
printf("time eclapse %d s for preprocessing!\n", (end_preprocess-start_t)/1000000);
enum states {Known, Alive, FarAway, Trial, BOUNDARY};
long offset_y, offset_z;
offset_y=sx;
offset_z=sx*sy;
long neighborhood_6[6] = {-1, 1, -offset_y, offset_y, -offset_z, offset_z};
long neighborhood_26[26] = {-1, 1, -offset_y, offset_y, -offset_z, offset_z,
-offset_y-1, -offset_y+1, -offset_y-offset_z, -offset_y+offset_z,
offset_y-1, offset_y+1, offset_y-offset_z, offset_y+offset_z,
offset_z-1, offset_z+1, -offset_z-1, -offset_z+1,
-1-offset_y-offset_z, -1-offset_y+offset_z, -1+offset_y-offset_z, -1+offset_y+offset_z,
1-offset_y-offset_z, 1-offset_y+offset_z, 1+offset_y-offset_z, 1+offset_y+offset_z};
long neighbors = 26;
long bound_idx = (sz-1)*sx*sy + (sy-1)*sx + sx-1;
//Fast Marching
HeapMinSort heap(pagesz);
// initial state heap
unsigned char* state = new unsigned char[pagesz];
unsigned char* phi = new unsigned char [pagesz];
bool* inserted = new bool [pagesz];
for(long k = 0; k < sz; k++)
{
long idxk = k*offset_z;
for(long j = 0; j < sy; j++)
{
long idxj = idxk + j*offset_y;
for(long i = 0, idx = idxj; i < sx; i++, idx++)
{
phi[idx] = 255;
state[idx] = BOUNDARY;
inserted[idx] = false;
if(i==0 || i==sx-1 || j==0 || j==sy-1 || k==0 || k==sz-1)
continue;
if( i==seed_x && j==seed_y && k==seed_z )
{
heap.insert(idx, 0);
phi[idx] = 0;
state[idx] = Known;
inserted[idx] = true;
}
else
state[idx] = FarAway;
}
}
}
// //
// progress.setValue(++i_progress);
long count=1;
long wc=0;
// del a point from the heap
long idx;
float weight;
while( heap.del(&idx, &weight) )
{
if( state[idx] == Alive ) continue;
// using region growing critera here
if( state[idx] != Known )
{
for(int ineighbor=0; ineighbor<neighbors; ineighbor++)
{
long n_idx = idx + neighborhood_26[ineighbor];
if(n_idx<bound_idx && n_idx>0)
{
if(phi[n_idx] == 0 && (fabs(data1d[idx] - seed_val)<=range_val))
{
phi[idx] = 0;
break;
}
}
}
}
else
{
phi[idx] = 0;
}
count--; wc++;
//set processed one to state "Alive"
state[idx] = Alive;
//find new neighbors and added to heap
for(int ineighbor=0; ineighbor<neighbors; ineighbor++)
{
long n_idx = idx + neighborhood_26[ineighbor];
if(n_idx<bound_idx && n_idx>0)
{
if( (state[n_idx]==FarAway || state[n_idx]==Trial) && inserted[n_idx]==false)
{
heap.insert(n_idx, phi[n_idx]+wc); count++;
state[n_idx] = Trial;
inserted[n_idx] = true;
}
}
}
}
// de-alloc
if (inserted) {delete []inserted; inserted=0;}
if (state) {delete []state; state=0;}
//----------------------------------------------------------------------------------------------------------------------------------
// third scan
progress.setValue(++i_progress);
int end_rgn = clock();
printf("time eclapse %d s for region growing!\n", (end_rgn-end_preprocess)/1000000);
// dist transform
//----------------------------------------------------------------------------------------------------------------------------------
long sz_data[4];
sz_data[0]=sx; sz_data[1]=sy; sz_data[2]=sz; sz_data[3]=1;
long *pDist = new long [pagesz];
if (!pDist)
{
printf("Fail to allocate memory.\n");
return;
}
long *pLabel = new long [pagesz];
if (!pLabel)
{
printf("Fail to allocate memory.\n");
return;
}
unsigned char *pData = new unsigned char [2*pagesz]; // first filled and second dist map
if (!pData)
{
printf("Fail to allocate memory.\n");
return;
}
for(long k = 0; k < sz; k++)
{
long idxk = k*offset_z;
for(long j = 0; j < sy; j++)
{
long idxj = idxk + j*offset_y;
for(long i = 0, idx = idxj; i < sx; i++, idx++)
{
if(i==0 || i==sx-1 || j==0 || j==sy-1 || k==0 || k==sz-1 || phi[idx]==0) // background and boundary
{
pData[idx] = 0;
pData[idx + pagesz] = 0;
}
else
{
pData[idx] = 1; //data1d[idx];
pData[idx + pagesz] = 1;
}
}
}
}
// de-alloc
if (phi) {delete []phi; phi=0;}
// dist transform
dt3d_binary(pData, pDist, pLabel, sz_data, 1);
long maxtest=0, mintest=INF;
for(long i=0; i<pagesz; i++)
{
long tmp=pDist[i];
if(maxtest<tmp) maxtest=tmp;
if(mintest>tmp) mintest=tmp;
}
maxtest -= mintest;
if(maxtest)
{
for(long i=0; i<pagesz; i++)
{
unsigned char tmp = 255*(pDist[i]-mintest)/maxtest;
// image blending
long tmp1 = tmp + data1d[i];
pData[i] = (tmp1>255)?255:tmp1; // sum
pData[i + pagesz] = tmp;
}
}
// de-alloc
if (data1d) {delete []data1d; data1d=0;} //
if (pDist) {delete []pDist; pDist=0;}
if (pLabel) {delete []pLabel; pLabel=0;}
//----------------------------------------------------------------------------------------------------------------------------------
int end_dist = clock();
printf("time eclapse %d s for dist computing!\n", (end_dist-end_rgn)/1000000);
progress.setValue(num_progress);
Image4DSimple p4DImage;
p4DImage.setData((unsigned char*)pData, sx, sy, sz, 2, subject->datatype);
v3dhandle newwin = callback.newImageWindow();
callback.setImage(newwin, &p4DImage);
callback.setImageName(newwin, QString("filled_image"));
callback.updateImageWindow(newwin);
}
void ThreadedTracer::run(){
qDebug()<<"loadScan input: "<<latestString;
//QString latestString = getFileString();
// latestString =QString("/data/mat/BRL/DATA_FOR_GROUP/testDataForZhi/ZSeries-06092016-1407-8470/ZSeries-06092016-1407-8470_Cycle00001_Ch1_000001.ome.tif");
// bool isAdaptive = 1;
// int methodChoice = 1;
//LandmarkList inputRootList;
QString fString;
fString = QString("Cycle%1").arg(tileNumber,5,10,QLatin1Char('0'));
qDebug()<<tileNumber;
QList<LandmarkList> newTipsList;
LandmarkList newTargetList;
QFileInfo imageFileInfo = QFileInfo(latestString);
if (imageFileInfo.isReadable()){
Image4DSimple * pNewImage = cb->loadImage(latestString.toLatin1().data());
QDir imageDir = imageFileInfo.dir();
QStringList filterList;
filterList.append(QString("*").append(fString).append("_Ch").append(channel).append("*.tif"));
qDebug()<<"filterlist.first()"<<filterList.first();
imageDir.setNameFilters(filterList);
QStringList fileList = imageDir.entryList();
//use this to id the number of images in the stack (in one channel?!)
V3DLONG x = pNewImage->getXDim();
V3DLONG y = pNewImage->getYDim();
V3DLONG nFrames = fileList.length();
V3DLONG tunits = x*y*nFrames;
unsigned short int * total1dData = new unsigned short int [tunits];
unsigned short int * total1dData_mip= new unsigned short int [x*y];
for(V3DLONG i =0 ; i < x*y; i++)
total1dData_mip[i] = 0;
V3DLONG totalImageIndex = 0;
double p_vmax=0;
qDebug()<<"nFrames = "<<nFrames;
for (int f=0; f<nFrames; f++){
qDebug()<<fileList[f];
Image4DSimple * pNewImage = cb->loadImage(imageDir.absoluteFilePath(fileList[f]).toLatin1().data());
if (pNewImage->valid()){
unsigned short int * data1d = 0;
data1d = new unsigned short int [x*y];
data1d = (unsigned short int*)pNewImage->getRawData();
for (V3DLONG i = 0; i< (x*y); i++)
{
total1dData[totalImageIndex]= data1d[i];
if(data1d[i] > p_vmax) p_vmax = data1d[i];
if(total1dData_mip[i] < data1d[i]) total1dData_mip[i] = data1d[i];
totalImageIndex++;
}
if(data1d) {delete []data1d; data1d = 0;}
}else{
qDebug()<<imageDir.absoluteFilePath(fileList[f])<<" failed!";
}
}
Image4DSimple* total4DImage = new Image4DSimple;
total4DImage->setData((unsigned char*)total1dData, x, y, nFrames, 1, V3D_UINT16);
Image4DSimple* total4DImage_mip = new Image4DSimple;
total4DImage_mip->setData((unsigned char*)total1dData_mip, x, y, 1, 1, V3D_UINT16);
QString swcString = saveDirString;
swcString.append("/x_").append(QString::number((int)tileLocation.x)).append("_y_").append(QString::number((int)tileLocation.y)).append("_").append(imageFileInfo.fileName()).append(fString).append(".swc");
QString scanDataFileString = saveDirString;
scanDataFileString.append("/").append("scanData.txt");
qDebug()<<scanDataFileString;
QFile saveTextFile;
saveTextFile.setFileName(scanDataFileString);// add currentScanFile
if (!saveTextFile.isOpen()){
if (!saveTextFile.open(QIODevice::Text|QIODevice::Append )){
qDebug()<<"unable to save file!";
return;} }
QTextStream outputStream;
outputStream.setDevice(&saveTextFile);
total4DImage->setOriginX(tileLocation.x);
total4DImage->setOriginY(tileLocation.y);
qDebug()<<total4DImage->getOriginX();
outputStream<< (int) total4DImage->getOriginX()<<" "<< (int) total4DImage->getOriginY()<<" "<<swcString<<" "<< (int) x<<" "<< (int) y<<" "<<"\n";
saveTextFile.close();
V3DLONG mysz[4];
mysz[0] = total4DImage->getXDim();
mysz[1] = total4DImage->getYDim();
mysz[2] = total4DImage->getZDim();
mysz[3] = total4DImage->getCDim();
tileLocation.ev_pc1 = (double) total4DImage->getXDim();
tileLocation.ev_pc2 = (double) total4DImage->getYDim();
QString imageSaveString = saveDirString;
// add bit of code to image green - red channels. This will require an additional argument or another signal/slot combination to monitor the value of a combobox in the GUI...
// add button to do || nT on mXtls
//convert to 8bit image using 8 shiftnbits
unsigned char * total1dData_8bit = 0;
try
{
total1dData_8bit = new unsigned char [tunits];
}
catch (...)
{
v3d_msg("Fail to allocate memory in total1dData_8bit.\n");
return;
}
double dn = pow(2.0, double(5));
for (V3DLONG i=0;i<tunits;i++)
{
double tmp = (double)(total1dData[i]) / dn;
if (tmp>255) total1dData_8bit[i] = 255;
else
total1dData_8bit[i] = (unsigned char)(tmp);
}
total4DImage->setData((unsigned char*)total1dData_8bit, x, y, nFrames, 1, V3D_UINT8);
imageSaveString.append("/x_").append(QString::number((int)tileLocation.x)).append("_y_").append(QString::number((int)tileLocation.y)).append("_").append(imageFileInfo.fileName()).append(imageFileInfo.fileName()).append(fString).append(".v3draw");
simple_saveimage_wrapper(*cb, imageSaveString.toLatin1().data(),(unsigned char *)total1dData_8bit, mysz, V3D_UINT8);
qDebug()<<"=== immediately before tracing =====";
//-------------
V3DPluginArgItem arg;
V3DPluginArgList input;
V3DPluginArgList output;
QString full_plugin_name;
QString func_name;
arg.type = "random";std::vector<char*> arg_input;
std:: string fileName_Qstring(imageSaveString.toStdString());char* fileName_string = new char[fileName_Qstring.length() + 1]; strcpy(fileName_string, fileName_Qstring.c_str());
arg_input.push_back(fileName_string);
arg.p = (void *) & arg_input; input<< arg;
char* char_swcout = new char[swcString.length() + 1];strcpy(char_swcout, swcString.toStdString().c_str());
arg.type = "random";std::vector<char*> arg_output;arg_output.push_back(char_swcout); arg.p = (void *) & arg_output; output<< arg;
arg.type = "random";
std::vector<char*> arg_para;
arg_para.push_back("1");
arg_para.push_back("1");
full_plugin_name = "neuTube";
func_name = "neutube_trace";
arg.p = (void *) & arg_para; input << arg;
if(!cb->callPluginFunc(full_plugin_name,func_name,input,output))
{
qDebug()<<("Can not find the tracing plugin!\n");
return;
}
emit done();
}else{
qDebug()<<"invalid image";
}
}
