src/Tools/rec3d/CheckOfOrientation/src/CheckOfOrientation.c

   1 /*
   2 # CheckOfOrientation : $Revision$
   3 # $Date$
   4 # Created by $Author$
   5 # Usage : CheckOfOrientation
   6 # Attention
   7 #   $Loccker$
   8 #       $State$
   9 #
  10 */
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <math.h>
  15 #define GLOBAL_DECLARATION
  16 #include "../inc/config.h"
  17
  18 #define DEBUG
  19 #define WORDLEN 1024
  20 #include "genUtil.h"
  21 #include "Memory.h"
  22 #include "Matrix3D.h"
  23 #include "eosString.h"
  24
  25 typedef struct lCheckOfOrientationInfo {
  26         int        FileNum;
  27         int        LineNum;
  28         char**     ResultFileName;
  29
  30         char**     FileName;
  31         char***    RotationalMode;
  32         float**    RotationalAnglePhi;
  33         float**    RotationalAngleTheta;
  34         float**    RotationalAnglePsi;
  35
  36         Matrix3D** DifferentialMatrix;
  37 } lCheckOfOrientationInfo;
  38
  39 /*
  40 typedef enum lCheckOfOrientationMode {
  41         a=0,
  42         b=1
  43 } lCheckOfOrientationMode;
  44 */
  45
  46 void
  47 __InputFileRead(lCheckOfOrientationInfo* linfo, int mode);
  48
  49 void
  50 lCheckOfOrientation(lCheckOfOrientationInfo* linfo, int mode);
  51
  52 int
  53 main(int argc, char* argv[])
  54 {
  55         CheckOfOrientationInfo  info;
  56         lCheckOfOrientationInfo linfo;
  57         int                     i, j;
  58         double                  value;
  59         double                  valueSum;
  60
  61         init0(&info);
  62     argCheck(&info, argc, argv);
  63     init1(&info);
  64
  65         linfo.FileNum = (int)info.flagInList;
  66         linfo.ResultFileName = MemoryAllocate(char*, linfo.FileNum, "in main");
  67         for(i=0; i<linfo.FileNum; i++){
  68                 linfo.ResultFileName[i] = MemoryAllocate(char, WORDLEN, "in main");
  69                 strcpy(linfo.ResultFileName[i], info.InList[i]);
  70         }
  71
  72         DEBUGPRINT("Program Start\n");
  73
  74         __InputFileRead(&linfo, 0);
  75         lCheckOfOrientation(&linfo, 0);
  76
  77         for(i=0; i<linfo.FileNum; i++){
  78                 fprintf(info.fptOut, "%s :\n", linfo.ResultFileName[i]);
  79                 fprintf(info.fptOutV, "%s :\n", linfo.ResultFileName[i]);
  80                 valueSum = 0;
  81         for(j=0; j<linfo.LineNum; j++){
  82                 fprintf(info.fptOut, ">>%s\n",linfo.FileName[j]);
  83                 fprintf(info.fptOut, "%6.3f %6.3f %6.3f\n", linfo.DifferentialMatrix[i][j][0][0],
  84                                                             linfo.DifferentialMatrix[i][j][0][1],
  85                                                                                                         linfo.DifferentialMatrix[i][j][0][2]);
  86                 fprintf(info.fptOut, "%6.3f %6.3f %6.3f\n", linfo.DifferentialMatrix[i][j][1][0],
  87                                                             linfo.DifferentialMatrix[i][j][1][1],
  88                                                                                                         linfo.DifferentialMatrix[i][j][1][2]);
  89                 fprintf(info.fptOut, "%6.3f %6.3f %6.3f\n", linfo.DifferentialMatrix[i][j][2][0],
  90                                                             linfo.DifferentialMatrix[i][j][2][1],
  91                                                                                                         linfo.DifferentialMatrix[i][j][2][2]);
  92
  93                 value = ((1-linfo.DifferentialMatrix[i][j][0][0])
  94                             +(1-linfo.DifferentialMatrix[i][j][1][1])
  95                             +(1-linfo.DifferentialMatrix[i][j][2][2])
  96                                 )/3;
  97                 valueSum += value;
  98                 fprintf(info.fptOutV, "%f\n", value);
  99         }
 100                 fprintf(info.fptOut, "\n");
 101                 fprintf(info.fptOutV, "Sum: %f  Ave: %f\n\n", valueSum, valueSum/linfo.LineNum);
 102         }
 103         fclose(info.fptOut);
 104         DEBUGPRINT("Program Start\n");
 105         exit(EXIT_SUCCESS);
 106 }
 107
 108 void
 109 additionalUsage()
 110 {
 111         fprintf(stderr, "\n");
 112         fprintf(stderr, "----------- Output file  -------------\n");
 113         fprintf(stderr, "-o  : output Matrix data\n");
 114         fprintf(stderr, "-ov : output Value data\n");
 115         fprintf(stderr, "\n");
 116 }
 117
 118 void
 119 __InputFileRead(lCheckOfOrientationInfo* linfo, int mode)
 120 {
 121         int   i, j;
 122         char* s;
 123         FILE* fpt;
 124
 125         s = MemoryAllocate(char, WORDLEN, "in __InputFileRead");
 126         linfo->LineNum = 0;
 127         if((fpt = fopen(linfo->ResultFileName[0], "r")) == NULL){
 128                 fprintf(stderr, "File Not Open !!\n");
 129                 exit(1);
 130         }
 131         fseek(fpt, 0L, SEEK_SET);
 132         while((stringGetFromFile(s, "", fpt, stdout, 3)) != NULL){
 133                 linfo->LineNum++;
 134         }
 135         fseek(fpt, 0L, SEEK_SET);
 136         linfo->FileName = MemoryAllocate(char*, linfo->LineNum, "in __InputFileRead");
 137         for(i=0; i<linfo->LineNum; i++){
 138                 linfo->FileName[i] = MemoryAllocate(char, WORDLEN, "in __InputFileRead");
 139                 stringGetFromFile(s, "", fpt, stdout, 3);
 140                 stringCopy(linfo->FileName[i], stringGetNthWord(s, 1, " ,\t"), WORDLEN-1);
 141         }
 142         fclose(fpt);
 143
 144         linfo->RotationalMode         = MemoryAllocate(char**, linfo->FileNum, "in __InputFileRead");
 145         linfo->RotationalAnglePhi     = MemoryAllocate(float*, linfo->FileNum, "in __InputFileRead");
 146         linfo->RotationalAngleTheta   = MemoryAllocate(float*, linfo->FileNum, "in __InputFileRead");
 147         linfo->RotationalAnglePsi     = MemoryAllocate(float*, linfo->FileNum, "in __InputFileRead");
 148         for(i=0; i<linfo->FileNum; i++){
 149                 linfo->RotationalMode[i]       = MemoryAllocate(char*,  linfo->LineNum, "in __InputFileRead");
 150                 linfo->RotationalAnglePhi[i]   = MemoryAllocate(float, linfo->LineNum, "in __InputFileRead");
 151                 linfo->RotationalAngleTheta[i] = MemoryAllocate(float, linfo->LineNum, "in __InputFileRead");
 152                 linfo->RotationalAnglePsi[i]   = MemoryAllocate(float, linfo->LineNum, "in __InputFileRead");
 153                 for(j=0; j<linfo->LineNum; j++){
 154                         linfo->RotationalMode[i][j] = MemoryAllocate(char, 5, "in __InputFileRead");
 155                 }
 156         }
 157
 158         for(i=0; i<linfo->FileNum; i++){
 159                 if((fpt = fopen(linfo->ResultFileName[i], "r")) == NULL){
 160                         fprintf(stderr, "File Not Open !!\n");
 161                         exit(1);
 162                 }
 163                 fseek(fpt, 0L, SEEK_SET);
 164                 for(j=0; j<linfo->LineNum; j++){
 165                         stringGetFromFile(s, "", fpt, stdout, 3);
 166                         stringCopy(linfo->RotationalMode[i][j], stringGetNthWord(s, 2, " ,\t"), 4);
 167                         linfo->RotationalAnglePhi[i][j]   = (float)stringGetNthRealData(s, 3, " ,\t")*RADIAN;
 168                         linfo->RotationalAngleTheta[i][j] = (float)stringGetNthRealData(s, 4, " ,\t")*RADIAN;
 169                         linfo->RotationalAnglePsi[i][j]   = (float)stringGetNthRealData(s, 5, " ,\t")*RADIAN;
 170                 }
 171                 fclose(fpt);
 172         }
 173         free(s);
 174 }
 175
 176 void
 177 lCheckOfOrientation(lCheckOfOrientationInfo* linfo, int mode)
 178 {
 179         int       i, j;
 180         Matrix3D* BasedMatrix;
 181         Matrix3D* RotationalMatrix;
 182
 183         linfo->DifferentialMatrix = MemoryAllocate(Matrix3D*, linfo->FileNum, "in lCheckOfOrientation");
 184         for(i=0; i<linfo->FileNum; i++){
 185                 linfo->DifferentialMatrix[i] = MemoryAllocate(Matrix3D, linfo->LineNum, "in lCheckOfOrientation");
 186         }
 187
 188         BasedMatrix      = MemoryAllocate(Matrix3D, 2, "in lCheckOfOrientation");
 189         RotationalMatrix = MemoryAllocate(Matrix3D, 2, "in lCheckOfOrientation");
 190
 191         matrix3DRotationAntiSetFollowingEulerAngle(BasedMatrix[0],
 192                                                                                            linfo->RotationalMode[0][0],
 193                                                                                            linfo->RotationalAnglePhi[0][0],
 194                                                                                            linfo->RotationalAngleTheta[0][0],
 195                                                                                            linfo->RotationalAnglePsi[0][0],
 196                                                                                            MATRIX_3D_MODE_INITIALIZE);
 197         for(i=0; i<linfo->FileNum; i++){
 198                 matrix3DRotationSetFollowingEulerAngle(RotationalMatrix[0],
 199                                                                                            linfo->RotationalMode[i][0],
 200                                                                                            linfo->RotationalAnglePhi[i][0],
 201                                                                                            linfo->RotationalAngleTheta[i][0],
 202                                                                                            linfo->RotationalAnglePsi[i][0],
 203                                                                                            MATRIX_3D_MODE_INITIALIZE);
 204         for(j=0; j<linfo->LineNum; j++){
 205                 matrix3DRotationSetFollowingEulerAngle(BasedMatrix[1],
 206                                                                                            linfo->RotationalMode[0][j],
 207                                                                                            linfo->RotationalAnglePhi[0][j],
 208                                                                                            linfo->RotationalAngleTheta[0][j],
 209                                                                                            linfo->RotationalAnglePsi[0][j],
 210                                                                                            MATRIX_3D_MODE_INITIALIZE);
 211
 212                 matrix3DRotationAntiSetFollowingEulerAngle(RotationalMatrix[1],
 213                                                                                                    linfo->RotationalMode[i][j],
 214                                                                                                    linfo->RotationalAnglePhi[i][j],
 215                                                                                                    linfo->RotationalAngleTheta[i][j],
 216                                                                                                    linfo->RotationalAnglePsi[i][j],
 217                                                                                                    MATRIX_3D_MODE_INITIALIZE);
 218
 219                 matrix3DInit(linfo->DifferentialMatrix[i][j]);
 220                 matrix3DMultiplyInv(RotationalMatrix[1], linfo->DifferentialMatrix[i][j]);
 221                 matrix3DMultiplyInv(RotationalMatrix[0], linfo->DifferentialMatrix[i][j]);
 222                 matrix3DMultiplyInv(BasedMatrix[0],      linfo->DifferentialMatrix[i][j]);
 223                 matrix3DMultiplyInv(BasedMatrix[1],      linfo->DifferentialMatrix[i][j]);
 224         }
 225         }
 226         free(BasedMatrix);
 227         free(RotationalMatrix);
 228 }