+
+ vector3D ori1;
+ vector3D ori2;
+
+ ori1.x = iop[0]; ori1.y = iop[1]; ori1.z = iop[2];
+ ori1.x = iop[3]; ori2.y = iop[4]; ori2.z = iop[5];
+
+ // two perpendicular vectors describe one plane
+ float dicPlane[6][2][3] =
+ { { {1, 0, 0 },{0, 1, 0 } }, // Axial
+ { {1, 0, 0 },{0, 0, -1 } }, // Coronal
+ { {0, 1, 0 },{0, 0, -1 } }, // Sagittal
+ { { 0.8, 0.5, 0.0 },{-0.1, 0.1 , -0.95 } }, // Axial - HEART
+ { { 0.8, 0.5, 0.0 },{-0.6674, 0.687, 0.1794} }, // Coronal - HEART
+ { {-0.1, 0.1, -0.95},{-0.6674, 0.687, 0.1794} } // Sagittal - HEART
+ };
+
+ vector3D refA;
+ vector3D refB;
+ int i = 0;
+ Res res; // [ <result> , <memory of the last succes calcule> ]
+ res.first = 0;
+ res.second = 99999;
+ for (int numDicPlane=0; numDicPlane<6; numDicPlane++)
+ {
+ i = i + 1;
+ // refA=plane[0]
+ refA.x = dicPlane[numDicPlane][0][0];
+ refA.y = dicPlane[numDicPlane][0][1];
+ refA.z = dicPlane[numDicPlane][0][2];
+ // refB=plane[1]
+ refB.x = dicPlane[numDicPlane][1][0];
+ refB.y = dicPlane[numDicPlane][1][1];
+ refB.z = dicPlane[numDicPlane][1][2];
+ res=VerfCriterion( i, CalculLikelyhood2Vec(refA,refB,ori1,ori2), res );
+ res=VerfCriterion( -i, CalculLikelyhood2Vec(refB,refA,ori1,ori2), res );
+ }
+ delete iop;
+ return res.first;
+/*
+// i=0
+// res=[0,99999] ## [ <result> , <memory of the last succes calculus> ]
+// for plane in dicPlane:
+// i=i+1
+// refA=plane[0]
+// refB=plane[1]
+// res=self.VerfCriterion( i , self.CalculLikelyhood2Vec(refA,refB,ori1,ori2) , res )
+// res=self.VerfCriterion( -i , self.CalculLikelyhood2Vec(refB,refA,ori1,ori2) , res )
+// return res[0]
+*/
+
+}
+
+// FIXME. Seriously who wrote that !
+// Haven't you ever heard of so called reference in c++
+Res File::VerfCriterion(int typeCriterion, float criterionNew, Res res)
+{
+ float criterion = res.second;
+ if (criterionNew < criterion)
+ {
+ res.first = criterionNew;
+ res.second = typeCriterion;
+ }
+/*
+// type = res[0]
+// criterion = res[1]
+// # if criterionNew<0.1 and criterionNew<criterion:
+// if criterionNew<criterion:
+// criterion=criterionNew
+// type=typeCriterion
+// return [ type , criterion ]
+*/
+ return res;
+}
+
+inline double square_dist(vector3D const &v1, vector3D const & v2)
+{
+ double res;
+ res = (v1.x - v2.x)*(v1.x - v2.x) +
+ (v1.y - v2.y)*(v1.y - v2.y) +
+ (v1.z - v2.z)*(v1.z - v2.z);
+ return res;
+}
+
+float File::CalculLikelyhood2Vec(vector3D const & refA, vector3D const &refB,
+ vector3D const & ori1, vector3D const &ori2)
+{
+// # ------------------------- Purpose : -----------------------------------
+// # - This function determines the orientation similarity of two planes.
+// # Each plane is described by two vectors.
+// # ------------------------- Parameters : --------------------------------
+// # - <refA> : - type : vector 3D (float)
+// # - <refB> : - type : vector 3D (float)
+// # - Description of the first plane
+// # - <ori1> : - type : vector 3D (float)
+// # - <ori2> : - type : vector 3D (float)
+// # - Description of the second plane
+// # ------------------------- Return : ------------------------------------
+// # float : 0 if the planes are perpendicular. While the difference of
+// # the orientation between the planes are big more enlarge is
+// # the criterion.
+// # ------------------------- Other : -------------------------------------
+// # The calculus is based with vectors normalice
+
+ vector3D ori3 = ProductVectorial(ori1,ori2);
+ vector3D refC = ProductVectorial(refA,refB);
+ double res = square_dist(refC, ori3);
+
+/*
+// ori3=self.ProductVectorial(ori1,ori2)
+// refC=self.ProductVectorial(refA,refB)
+// res=math.pow(refC[0]-ori3[0],2) + math.pow(refC[1]-ori3[1],2) + math.pow(refC[2]-ori3[2],2)
+// return math.sqrt(res)
+*/
+ return sqrt(res);
+}
+
+vector3D File::ProductVectorial(vector3D const & vec1, vector3D const & vec2)
+{
+
+// # ------------------------- Purpose : -----------------------------------
+// # - Calculus of the poduct vectorial between two vectors 3D
+// # ------------------------- Parameters : --------------------------------
+// # - <vec1> : - type : vector 3D (float)
+// # - <vec2> : - type : vector 3D (float)
+// # ------------------------- Return : ------------------------------------
+// # (vec) : - Vector 3D
+// # ------------------------- Other : -------------------------------------
+
+ vector3D vec3;
+ vec3.x = vec1.y*vec2.z - vec1.z*vec2.y;
+ vec3.y = -( vec1.x*vec2.z - vec1.z*vec2.x);
+ vec3.z = vec1.x*vec2.y - vec1.y*vec2.x;
+/*
+// vec3=[0,0,0]
+// vec3[0]=vec1[1]*vec2[2] - vec1[2]*vec2[1]
+// vec3[1]=-( vec1[0]*vec2[2] - vec1[2]*vec2[0])
+// vec3[2]=vec1[0]*vec2[1] - vec1[1]*vec2[0]
+*/
+ return vec3;