//$EK 2013-03-05 added
void IntegrationRule::DefineIntegrationRulePyramid(IntegrationRule & integrationRule, int ruleOrder)
{
// we use a ready function, which provides a tetrahedral integration rule
Vector x_z, xline, w_z, wline;
//$EK I don't know why in z-direction one needs in increased order???
//-------------------------------------------------------------------------
//FROM NGSolve ... prismatic integration rule (in intrule.cpp)
// const IntegrationRule & quadrule = SelectIntegrationRule (ET_QUAD, order);
// const IntegrationRule & segrule = SelectIntegrationRule (ET_SEGM, order+2);
//const IntegrationPoint & ipquad = quadrule[i]; // .GetIP(i);
//const IntegrationPoint & ipseg = segrule[j]; // .GetIP(j);
//point[0] = (1-ipseg(0)) * ipquad(0);
//point[1] = (1-ipseg(0)) * ipquad(1);
//point[2] = ipseg(0);
//weight = ipseg.Weight() * sqr (1-ipseg(0)) * ipquad.Weight();
//--------------------------------------------------------------------------
GetIntegrationRule(x_z, w_z, ruleOrder+2);
GetIntegrationRule(xline, wline, ruleOrder);
//adapt integration points to interval [0,1] instead of [-1,1]
for (int i = 1; i <= xline.Length(); ++i)
xline(i) = (xline(i) + 1.)/2.;
for (int i = 1; i <= x_z.Length(); ++i)
x_z(i) = (x_z(i) + 1.)/2.;
// and now we create a 3D integration rule
integrationRule.integrationPoints.SetLen(x_z.Length()*sqr(xline.Length()));
assert(x_z.Length() == w_z.Length());
assert(xline.Length() == wline.Length());
int cnt = 1;
for (int i = 1; i <= xline.GetLen(); i++)
for (int j = 1; j <= xline.GetLen(); j++)
for (int k = 1; k <= x_z.GetLen(); ++k)
{
double z = x_z(k);
integrationRule.integrationPoints(cnt).x = xline(i)*(1-z);
integrationRule.integrationPoints(cnt).y = xline(j)*(1-z);
integrationRule.integrationPoints(cnt).z = z;
//the /8. is due to the transformation of [-1,1] to [0,1]
integrationRule.integrationPoints(cnt).weight = w_z(k) * sqr(1- z) * wline(i) * wline(j)/8.;
cnt++;
}
}
int read_ct_tran(struct patient_struct *ppatient, QString *Result)
{
FILE *f_tran = NULL;
uint32_t file_typ, ser_head_length, block_length, ser_number, numb_of_slices;
char pat_name[80], comm[80], date[80];
uint32_t trafo_type;
uint32_t calculated;
uint32_t is_axial;
double marker[12][2];
double plate[16][2];
uint32_t missing;
uint32_t all_slices;
uint32_t elements_v_rev_mat;
uint32_t i, j, n;
double fov_by_2;
double global_inv_mat[4][4];
mat44_t mat;
mat44_t rev_mat;
vector<mat44_t> v_mat, v_rev_mat;
xyze Stereo_point_0;
xyze Stereo_point_1;
xyze Stereo_point_2;
xyze Stereo_point_3;
const int imax = 4;
double Edge_point_a[imax] = { 0.0, 0.0, 1.0, 1.0 };
double Edge_point_b[imax] = { 0.0, 1023.0, 1.0, 1.0 };
double Edge_point_c[imax] = { 1023.0, 1023.0, 1.0, 1.0 };
double Edge_point_d[imax] = { 1023.0, 0.0, 1.0, 1.0 };
double last_col_glo_matrix[imax] = { 0.0, 0.0, 0.0, 1.0 };
QTextStream ts(Result, IO_WriteOnly);
ts << "<B>Loading " << ppatient->Tra_File;
if ((f_tran = fopen(ppatient->Tra_File, "rb")) == NULL)
{
ts << ": failed!</B><br><br>";
return 1;
}
// read transformation header
if (fread(&file_typ, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_52 failed in ReadSTP3.cpp");
}
if (fread(&ser_head_length, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_53 failed in ReadSTP3.cpp");
}
if (fread(&block_length, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_54 failed in ReadSTP3.cpp");
}
if (fread(pat_name, 1, 80, f_tran) != 1)
{
fprintf(stderr, "fread_55 failed in ReadSTP3.cpp");
}
if (fread(comm, 1, 80, f_tran) != 1)
{
fprintf(stderr, "fread_56 failed in ReadSTP3.cpp");
}
if (fread(date, 1, 80, f_tran) != 1)
{
fprintf(stderr, "fread_57 failed in ReadSTP3.cpp");
}
if (fread(&ser_number, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_58 failed in ReadSTP3.cpp");
}
if (fread(&numb_of_slices, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_59 failed in ReadSTP3.cpp");
}
// read transformation for each slice
for (j = 1; j < numb_of_slices + 1; j++)
{
fseek(f_tran, block_length * j + ser_head_length, SEEK_SET);
if (fread(&trafo_type, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_60 failed in ReadSTP3.cpp");
}
if (fread(&calculated, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_61 failed in ReadSTP3.cpp");
}
if (fread(&is_axial, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_62 failed in ReadSTP3.cpp");
}
if (fread(marker, sizeof(marker), 1, f_tran) != sizeof(marker))
{
fprintf(stderr, "fread_63 failed in ReadSTP3.cpp");
}
if (fread(plate, sizeof(plate), 1, f_tran) != sizeof(plate))
{
fprintf(stderr, "fread_64 failed in ReadSTP3.cpp");
}
if (fread(&missing, 4, 1, f_tran) != 4)
{
fprintf(stderr, "fread_65 failed in ReadSTP3.cpp");
}
if (fread(mat.mat, sizeof(mat.mat), 1, f_tran) != sizeof(mat.mat))
{
fprintf(stderr, "fread_66 failed in ReadSTP3.cpp");
}
if (fread(rev_mat.mat, sizeof(rev_mat.mat), 1, f_tran) != sizeof(rev_mat.mat))
{
fprintf(stderr, "fread_67 failed in ReadSTP3.cpp");
}
v_mat.push_back(mat);
v_rev_mat.push_back(rev_mat);
}
fclose(f_tran);
all_slices = v_mat.size();
elements_v_rev_mat = v_rev_mat.size();
fov_by_2 = ppatient->Pixel_size * ppatient->Resolution / 2.0;
n = ppatient->No_Slices * 4;
// define for geting the glogal transformation matrix, using the
// singular value decomposition NR::svdcmp(x,w,v), and backsustitution NR::svbksb(x,w,v,b_x,x_x);
// here we used matrix defined in Numerical Recipes because are dinamics(we dont know how many members have)
Mat_DP x(n, 4), u(n, 4), v(4, 4);
Vec_DP w(4), b(n);
Vec_DP b_x(n), b_y(n), b_z(n);
Vec_DP x_x(n), x_y(n), x_z(n);
// define for geting the inverse glogal transformation matrix, using the Lower Up decomposition
// NR::ludcmp(global_mat,indx,d), and backsustitution NR::lubksb(global_mat,indx,col);
Mat_DP global_mat(4, 4);
Vec_DP col(4);
Vec_INT indx(4);
DP d;
for (i = 0; i < all_slices; i++)
{
// image coordinates
x[i * 4 + 0][0] = fov_by_2;
x[i * 4 + 0][1] = fov_by_2;
x[i * 4 + 0][2] = ppatient->Z_Table[i];
x[i * 4 + 0][3] = 1.0;
x[i * 4 + 1][0] = fov_by_2;
x[i * 4 + 1][1] = -fov_by_2;
x[i * 4 + 1][2] = ppatient->Z_Table[i];
x[i * 4 + 1][3] = 1.0;
x[i * 4 + 2][0] = -fov_by_2;
x[i * 4 + 2][1] = -fov_by_2;
x[i * 4 + 2][2] = ppatient->Z_Table[i];
x[i * 4 + 2][3] = 1.0;
x[i * 4 + 3][0] = -fov_by_2;
x[i * 4 + 3][1] = fov_by_2;
x[i * 4 + 3][2] = ppatient->Z_Table[i];
x[i * 4 + 3][3] = 1.0;
// Stereotactic coordinates
Stereo_point_0.x = 0.0;
Stereo_point_0.y = 0.0;
Stereo_point_0.z = 0.0;
Stereo_point_1.x = 0.0;
Stereo_point_1.y = 0.0;
Stereo_point_1.z = 0.0;
Stereo_point_2.x = 0.0;
Stereo_point_2.y = 0.0;
Stereo_point_2.z = 0.0;
Stereo_point_3.x = 0.0;
Stereo_point_3.y = 0.0;
Stereo_point_3.z = 0.0;
for (int f = 0; f <= 3; f++)
{
Stereo_point_0.x += v_mat[i].mat[f][1] * Edge_point_a[f];
Stereo_point_0.y += v_mat[i].mat[f][2] * Edge_point_a[f];
Stereo_point_0.z += v_mat[i].mat[f][3] * Edge_point_a[f];
Stereo_point_0.err = 1.0; // [0.0, 0.0, 1.0, 1,0]
Stereo_point_1.x += v_mat[i].mat[f][1] * Edge_point_b[f];
Stereo_point_1.y += v_mat[i].mat[f][2] * Edge_point_b[f];
Stereo_point_1.z += v_mat[i].mat[f][3] * Edge_point_b[f];
Stereo_point_1.err = 1.0; // [0.0, 1024.0, 1.0, 1,0]
Stereo_point_2.x += v_mat[i].mat[f][1] * Edge_point_c[f];
Stereo_point_2.y += v_mat[i].mat[f][2] * Edge_point_c[f];
Stereo_point_2.z += v_mat[i].mat[f][3] * Edge_point_c[f];
Stereo_point_2.err = 1.0; // [1024.0, 1024.0, 1.0, 1,0]
Stereo_point_3.x += v_mat[i].mat[f][1] * Edge_point_d[f];
Stereo_point_3.y += v_mat[i].mat[f][2] * Edge_point_d[f];
Stereo_point_3.z += v_mat[i].mat[f][3] * Edge_point_d[f];
Stereo_point_3.err = 1.0; // [1024.0, 0.0, 1.0, 1,0]
}
b_x[i * 4 + 0] = Stereo_point_0.x;
b_x[i * 4 + 1] = Stereo_point_1.x;
b_x[i * 4 + 2] = Stereo_point_2.x;
b_x[i * 4 + 3] = Stereo_point_3.x;
b_y[i * 4 + 0] = Stereo_point_0.y;
b_y[i * 4 + 1] = Stereo_point_1.y;
b_y[i * 4 + 2] = Stereo_point_2.y;
b_y[i * 4 + 3] = Stereo_point_3.y;
b_z[i * 4 + 0] = Stereo_point_0.z;
b_z[i * 4 + 1] = Stereo_point_1.z;
b_z[i * 4 + 2] = Stereo_point_2.z;
b_z[i * 4 + 3] = Stereo_point_3.z;
}
// solve linear equation
NR::svdcmp(x, w, v); // here we make the decomposition of the matrix X (image coordinate,for the for points in each slices)!
NR::svbksb(x, w, v, b_x, x_x);
NR::svbksb(x, w, v, b_y, x_y);
NR::svbksb(x, w, v, b_z, x_z);
// transformation matrix
for (i = 0; i < 4; i++)
{
ppatient->Global_Tra_Matrix[i][0] = x_x[i];
ppatient->Global_Tra_Matrix[i][1] = x_y[i];
ppatient->Global_Tra_Matrix[i][2] = x_z[i];
ppatient->Global_Tra_Matrix[i][3] = last_col_glo_matrix[i];
for (j = 0; j < 4; j++)
global_mat[i][j] = ppatient->Global_Tra_Matrix[i][j];
}
// calculate inverse matrix
NR::ludcmp(global_mat, indx, d);
for (j = 0; j < 4; j++)
{
for (i = 0; i < 4; i++)
col[i] = 0.0;
col[j] = 1.0;
NR::lubksb(global_mat, indx, col);
for (i = 0; i < 4; i++)
global_inv_mat[i][j] = col[i];
}
// print transformation info
ts << ": Ok</B>";
ts << "<br><br><B>Transformation Info</B>"; // <br> te salta una linea, con el primer B me lo escribiria to en negro pa especificar q solo queremos la linea esa se pone al final </B>
ts << "<pre>"; // si omito esta linea me escribe la dos matrices juntas sin ningun sentido!, y pq el otro no pasa na cuando se omite, ver #
ts << "Mat = <br>";
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
ppatient->Rev_Global_Tra_Matrix[i][j] = global_inv_mat[i][j];
ts << " " << ppatient->Global_Tra_Matrix[i][0]
<< " " << ppatient->Global_Tra_Matrix[i][1]
<< " " << ppatient->Global_Tra_Matrix[i][2]
<< " " << ppatient->Global_Tra_Matrix[i][3]
<< "<br>";
}
ts << "RevMat = <br>";
for (i = 0; i < 4; i++)
ts << " " << ppatient->Rev_Global_Tra_Matrix[i][0]
<< " " << ppatient->Rev_Global_Tra_Matrix[i][1]
<< " " << ppatient->Rev_Global_Tra_Matrix[i][2]
<< " " << ppatient->Rev_Global_Tra_Matrix[i][3]
<< "<br>";
ts << "<br></pre>";
return 0;
}
