[src] alle Elemente werden rotiert und das \delta richtig ausgewertet

[src] konverter von 3 auf 4 Koordinaten pro element + in Datei schreiben

git-svn-id: https://drops.fb12.tu-berlin.de/svn/bacc/trunk@29 26120e32-c555-405d-b3e1-1f783fb42516

diff --git a/src/build_A.cpp b/src/build_A.cpp
index 12b42b81d716461576fc9cd28a04f5d0f6746403..d880ef5b639e3d7e6776a1fc5afd6b3cc0f8cc5c 100644 (file)
--- a/src/build_A.cpp
+++ b/src/build_A.cpp
@@ -40,21 +40,22 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
        double * C = mxGetPr(prhs[0]);\r
        double * E = mxGetPr(prhs[1]);\r
 \r
+       double * x0 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * x1 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
-       double * x2 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * x3 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * xn = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * xa = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * xb = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
 \r
+       double * y0 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * y1 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
-       double * y2 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * y3 = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * yn = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * ya = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
        double * yb = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
 \r
        double * d = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
+       double * dt = mxGetPr(mxCreateDoubleMatrix(3, 1, mxREAL));\r
 \r
        double tmp;\r
 \r
@@ -63,23 +64,23 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
 \r
        //Ausrechnen\r
        for (j = 0; j < em; ++j) {\r
-               x1[0] = C[(int) E[j] - 1];\r
-               x1[1] = C[cm + (int) E[j] - 1];\r
-               x1[2] = C[2 * cm + (int) E[j] - 1];\r
+               x0[0] = C[(int) E[j] - 1];\r
+               x0[1] = C[cm + (int) E[j] - 1];\r
+               x0[2] = C[2 * cm + (int) E[j] - 1];\r
 \r
-               x2[0] = C[(int) E[em + j] - 1];\r
-               x2[1] = C[cm + (int) E[em + j] - 1];\r
-               x2[2] = C[2 * cm + (int) E[em + j] - 1];\r
+               x1[0] = C[(int) E[em + j] - 1];\r
+               x1[1] = C[cm + (int) E[em + j] - 1];\r
+               x1[2] = C[2 * cm + (int) E[em + j] - 1];\r
 \r
                x3[0] = C[(int) E[2 * em + j] - 1];\r
                x3[1] = C[cm + (int) E[2 * em + j] - 1];\r
                x3[2] = C[2 * cm + (int) E[2 * em + j] - 1];\r
 \r
                for (i = 0; i<3;++i)\r
-                       xa[i] = x2[i] - x1[i];\r
+                       xa[i] = x1[i] - x0[i];\r
 \r
                for (i = 0; i<3;++i)\r
-                       xb[i] = x3[i] - x1[i];\r
+                       xb[i] = x3[i] - x0[i];\r
 \r
                //Kreuzprodukt\r
                xn[0] = (xa[1]) * (xb[2]) - (xa[2]) * (xb[1]);\r
@@ -87,7 +88,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
                xn[2] = (xa[0]) * (xb[1]) - (xa[1]) * (xb[0]);\r
 \r
 \r
-\r
+               // Lageeigenschaften des Flaechenstuecks\r
                //if(xn[0]*xn[0]+xn[1]*xn[1]<xn[2]*xn[2])\r
                if (xn[2] != 0)\r
                        rx = 2;\r
@@ -110,28 +111,50 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
                else\r
                        rxb = 0;\r
 \r
+               //kleinste Ecke finden und fuer \delta verwenden\r
+\r
+               if(xa[rxa]>0){\r
+                       if(xb[rxb]>0){\r
+                               for (i = 0; i<3;++i)\r
+                                       dt[i] = - x0[i];\r
+                       }else{\r
+                               for (i = 0; i<3;++i)\r
+                                       dt[i] = - x1[i];\r
+                       }\r
+               }else{\r
+                       if(xb[rxb]>0){\r
+                               for (i = 0; i<3;++i)\r
+                                       dt[i] = - x3[i];\r
+                       }else{\r
+                               //for (i = 0; i<3;++i)\r
+                               //      d[i] = - x2[i];\r
+                               printf("Error! Daten existieren nicht. Zugriff auf vierten punkt");\r
+                       }\r
+               }\r
+\r
+\r
 \r
 \r
                // printf("(%d n- %f | %f | %f)\n",j,xn[0],xn[1],xn[2]);\r
 \r
                for (k = 0; k < em; ++k) {\r
-                       y1[0] = C[(int) E[k] - 1];\r
-                       y1[1] = C[cm + (int) E[k] - 1];\r
-                       y1[2] = C[2 * cm + (int) E[k] - 1];\r
+                       y0[0] = C[(int) E[k] - 1];\r
+                       y0[1] = C[cm + (int) E[k] - 1];\r
+                       y0[2] = C[2 * cm + (int) E[k] - 1];\r
 \r
-                       y2[0] = C[(int) E[em + k] - 1];\r
-                       y2[1] = C[cm + (int) E[em + k] - 1];\r
-                       y2[2] = C[2 * cm + (int) E[em + k] - 1];\r
+                       y1[0] = C[(int) E[em + k] - 1];\r
+                       y1[1] = C[cm + (int) E[em + k] - 1];\r
+                       y1[2] = C[2 * cm + (int) E[em + k] - 1];\r
 \r
                        y3[0] = C[(int) E[2 * em + k] - 1];\r
                        y3[1] = C[cm + (int) E[2 * em + k] - 1];\r
                        y3[2] = C[2 * cm + (int) E[2 * em + k] - 1];\r
 \r
                        for (i = 0; i<3;++i)\r
-                               ya[i] = y2[i] - y1[i];\r
+                               ya[i] = y1[i] - y0[i];\r
 \r
                        for (i = 0; i<3;++i)\r
-                               yb[i] = y3[i] - y1[i];\r
+                               yb[i] = y3[i] - y0[i];\r
 \r
                        yn[0] = (ya[1]) * (yb[2]) - (ya[2]) * (yb[1]);\r
                        yn[1] = (ya[2]) * (yb[0]) - (ya[0]) * (yb[2]);\r
@@ -158,22 +181,44 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
                        else\r
                                ryb = 0;\r
 \r
+                       //kleinste Ecke finden und fuer \delta verwenden\r
+\r
+                       if(ya[rya]>0){\r
+                               if(yb[ryb]>0){\r
+                                       for (i = 0; i<3;++i)\r
+                                               d[i] = dt[i] + y0[i];\r
+                               }else{\r
+                                       for (i = 0; i<3;++i)\r
+                                               d[i] = dt[i] + y1[i];\r
+                               }\r
+                       }else{\r
+                               if(yb[ryb]>0){\r
+                                       for (i = 0; i<3;++i)\r
+                                               d[i] = dt[i] + y3[i];\r
+                               }else{\r
+                                       //for (i = 0; i<3;++i)\r
+                                               //d[i] += y2[i];\r
+                                       printf("Error! Daten existieren nicht. Zugriff auf vierten punkt");\r
+                               }\r
+                       }\r
+\r
                        for (i = 0; i<3;++i)\r
-                               d[i] = y1[i] - x1[i];   // todo: Achtung -> geht davon aus das 1 die kleinste Ecke ist !\r
+                               d[i] = y0[i]-x0[i];\r
 \r
-                       //printf("(%d,%d)",rx,ry);\r
+                       printf("(%d,%d)",rx,ry);\r
                        if (rx == ry) {\r
-                               //printf("%d,%d@%d,%d",rxa,rxb,rya,ryb);\r
+                               printf("(%d,%d@%d,%d)",rxa,rxb,rya,ryb);\r
+                               printf("[%.2f,%.2f@%.2f,%.2f]\n",xa[rxa],xb[rxb],ya[rya],yb[ryb]);\r
                                if (rxa == rya) {\r
-                                       //printf("%d%d %.1f %.1f | %.1f %.1f || %.1f %.1f | %.1f %.1f || %.1f %.1f %.1f\n",j,k,x1[0], x2[0], x1[1], x3[1], y1[0],\r
-                                       //              y2[0], y1[1], y3[1], d[0], d[1], d[2]);\r
-                                       //printf("%d%d %.1f %.1f %.1f\n",j,k,d[0],d[1],d[2]);\r
+                                       //printf("%d%d %.1f %.1f | %.1f %.1f || %.1f %.1f | %.1f %.1f || %.1f %.1f %.1f\n",j,k,x0[0], x1[0], x0[1], x3[1], y0[0],\r
+                                       //              y1[0], y0[1], y3[1], d[0], d[1], d[2]);\r
+                                       printf("%d%d %.1f %.1f %.1f\n",j,k,d[0],d[1],d[2]);\r
                                        tmp = quad0Int(F_par, fabs(xa[rxa]), fabs(xb[rxb]),\r
                                                        fabs(ya[rxa]), fabs(yb[rxb]), d[rxa], d[rxb], d[rx]);\r
                                        //       printf("%d%d|%.2f\n",j,k,tmp);\r
                                } else{\r
-                                       //printf("%d%d %.1f %.1f | %.1f %.1f || %.1f %.1f | %.1f %.1f || %.1f %.1f %.1f\n",j,k,x1[0], x2[0], x1[1], x3[1], y1[0],\r
-                                       //              y2[0], y1[1], y3[1], d[0], d[1], d[2]);\r
+                                       //printf("%d%d %.1f %.1f | %.1f %.1f || %.1f %.1f | %.1f %.1f || %.1f %.1f %.1f\n",j,k,x0[0], x1[0], x0[1], x3[1], y0[0],\r
+                                       //              y1[0], y0[1], y3[1], d[0], d[1], d[2]);\r
                                        //printf("%d%d %.1f %.1f %.1f\n",j,k,d[0],d[1],d[2]);\r
                                        tmp = quad0Int(F_par, fabs(xa[rxa]), fabs(xb[rxb]),\r
                                                        fabs(yb[rxa]), fabs(ya[rxb]), d[rxa], d[rxb], d[rx]);\r
@@ -199,11 +244,11 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
 \r
        }\r
        //Rueckgabe (eventuell zurueck schreiben)\r
-       //   mxFree(x1);\r
-       //mxFree(x2);\r
+       //   mxFree(x0);\r
+       //mxFree(x1);\r
        //mxFree(x3);\r
+       //mxFree(y0);\r
        //mxFree(y1);\r
-       //mxFree(y2);\r
        //mxFree(y3);\r
        //mxFree(xn);\r
        //mxFree(yn);\r

diff --git a/src/exportCOEL.m b/src/exportCOEL.m
index 92a1212be37e65a82aa63add9d8cad837a1f1679..7dbe0866b6deebe6f613dacb0448f700caf09208 100644 (file)
--- a/src/exportCOEL.m
+++ b/src/exportCOEL.m
@@ -1,18 +1,46 @@
-function exportCOEL(coo, ele, file)
+function [coo, ele] = exportCOEL(coo, ele, file)
 %EXPORTCOEL Summary of this function goes here
 %   Detailed explanation goes here
 
-dat = fopen(file,'w');
+if(size(ele,2) == 3)
+  disp 'erweitere auf 4 Koordinaten pro Element'
+  ele = ele(:,[1 2 3 3]);
 
-    for i=1:size(coo,1);
-        fprintf(dat,'v %.4f %.4f %.4f\n',coo(i,:));
-    end
-        fprintf(dat,'\n');
-    for i=1:size(ele,1);
-        fprintf(dat,'f %.0f %.0f %.0f\n',ele(i,:));
-    end
+  for i = 1:size(ele,1);
+  
+    tri = ele(i,:);
+    a = (coo(tri(2),:)-coo(tri(1),:));
+    x = coo(tri(3),:) + a;
 
-fclose(dat);
+    found = 0;
+    for j = 1:size(coo,1)
+      if(coo(j,:) == x)
+        found = j;
+        break;
+      end
+    end
 
+    if(found == 0)
+      coo(j+1,:) = x;
+      ele(i,3) = j+1;
+    else
+      ele(i,3) = j;
+    end
+  end
+end
+if(size(ele,2)==4)
+%   disp 'schreibe in Datei'
+%   dat = fopen(file,'w');
+% 
+%       for i=1:size(coo,1);
+%           fprintf(dat,'v %.4f %.4f %.4f\n',coo(i,:));
+%       end
+%           fprintf(dat,'\n');
+%       for i=1:size(ele,1);
+%           fprintf(dat,'f %.0f %.0f %.0f %.0f\n',ele(i,:));
+%       end
+% 
+%   fclose(dat);
+end
 end
 

diff --git a/src/test_solveError.m b/src/test_solveError.m
index 3a9fba01840acc56d7e665aab48d468fcc579876..5f2c47a9060c62f71b1495ab6e7bf32a427fb9a4 100644 (file)
--- a/src/test_solveError.m
+++ b/src/test_solveError.m
@@ -2,7 +2,8 @@
 \r
 load exmpl_2DLShape\r
 \r
-coordinates = coordinates(:,[ 1 3 2]);\r
+% coordinates = coordinates(:,[ 1 3 2]);\r
+% elements(2,:) = elements(2,[ 2 3 1]);\r
 \r
 % [coordinates,elements]=refineQuad(coordinates,elements,ones(1,size(elements,1)));\r
 % [coordinates,elements]=refineQuad(coordinates,elements,ones(1,size(elements,1)));\r