Please enter the commit message for your changes. Lines starting

 with '#' will be ignored, and an empty message aborts the commit.

 On branch master
 Your branch is up to date with 'origin/master'.

 Changes to be committed:
	modified:   include/lmrcImageNormalizing.h
	modified:   src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.c
	modified:   src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.h
	modified:   src/Objects/DataManip/mrcImage/src/mrcImageInfo.c
	modified:   src/Tools/Config/Define.inc
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/Config/OptionControlFile
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/inc/mrcImageAbnormalValueRemove.h
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/argCheck.c
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/init.c
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.c
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.html
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.pane
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/test/Makefile
	modified:   src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/usage.c
	modified:   src/Tools/mrcImage/mrcImageNormalizing/Config/OptionControlFile
	modified:   src/Tools/mrcImage/mrcImageNormalizing/inc/mrcImageNormalizing.h
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/argCheck.c
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/init.c
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.c
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.html
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.pane
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/test/Makefile
	modified:   src/Tools/mrcImage/mrcImageNormalizing/src/usage.c
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/inc/mrcImageSeriesNormalizing.h
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/argCheck.c
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/init.c
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.c
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.html
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.pane
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/test/Makefile
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/test/test.init
	modified:   src/Tools/mrcImage/mrcImageSeriesNormalizing/src/usage.c

 Changes not staged for commit:
	modified:   hostdepend/ARM64MAC64 (new commits)
	modified:   include/eosMATH.h

diff --git a/include/lmrcImageNormalizing.h b/include/lmrcImageNormalizing.h
index 975e46f..e6c5b27 100644 (file)
--- a/include/lmrcImageNormalizing.h
+++ b/include/lmrcImageNormalizing.h
@@ -40,6 +40,7 @@ typedef struct lmrcImageNormalizingInfo {
        lmrcImageNormalizingParaTypeReal thresOfLowValueArea;
        lmrcImageNormalizingParaTypeReal thresOfHighValueArea;
        lmrcImageNormalizingMode Mode;
+    FILE* paramOut;
 } lmrcImageNormalizingInfo;
 /* struct end */
 

diff --git a/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.c b/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.c
index 4c9e798..db751dc 100755 (executable)
--- a/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.c
+++ b/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.c
@@ -79,6 +79,7 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
 
        switch(linfo->Mode) {
                case lmrcImageNormalizingModeDoubleExponential: {
+            fprintf(linfo->paramOut, "NormalizingMode: DoubleExp\n");
                        lhist = 100;
                        nexp  = 2;
                        lmrcImageHistgram(&hist, lhist, in);
@@ -136,9 +137,11 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "(min,max): %f %f\n", a[5], a[2]);
                        break;
                }
                case lmrcImageNormalizingModeMinMax: {
+            fprintf(linfo->paramOut, "NormalizingMode: MinMax\n");
                        for(x=0; x<in->HeaderN.x; x++) {
                                for(y=0; y<in->HeaderN.y; y++) {
                                        for(z=0; z<in->HeaderN.z; z++) {
@@ -148,9 +151,11 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "(min,max): %f %f\n", in->HeaderAMin, in->HeaderAMax);
                        break;
                }
                case lmrcImageNormalizingModeMin75percent: {
+            fprintf(linfo->paramOut, "NormalizingMode: MinMax-A*0.75+B\n");
                        for(x=0; x<in->HeaderN.x; x++) {
                                for(y=0; y<in->HeaderN.y; y++) {
                                        for(z=0; z<in->HeaderN.z; z++) {
@@ -160,9 +165,11 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "(min,max): %f %f\n", in->HeaderAMin, in->HeaderAMax);
                        break;
                }
                case lmrcImageNormalizingModeUsingContour: {
+            fprintf(linfo->paramOut, "NormalizingMode: ContourMinMax\n");
                        for(x=0; x<in->HeaderN.x; x++) {
                                for(y=0; y<in->HeaderN.y; y++) {
                                        for(z=0; z<in->HeaderN.z; z++) {
@@ -172,9 +179,11 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "(min,max): %f %f\n", linfo->ContourMin, linfo->ContourMax);
                        break;
                }
                case lmrcImageNormalizingModeUsingContourWithSolventFlattening: {
+            fprintf(linfo->paramOut, "NormalizingMode: ContourMinMaxWithSoventFlattenng\n");
                        for(x=0; x<in->HeaderN.x; x++) {
                                for(y=0; y<in->HeaderN.y; y++) {
                                        for(z=0; z<in->HeaderN.z; z++) {
@@ -187,9 +196,12 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "(min,max): %f %f\n", linfo->ContourMin, linfo->ContourMax);
+            fprintf(linfo->paramOut, "Solavent:  %f\n", linfo->ContourSolvent);
                        break;
                }
                case lmrcImageNormalizingModeNoEstimation: {
+            fprintf(linfo->paramOut, "NormalizingMode: A*data+B\n");
                        for(x=0; x<in->HeaderN.x; x++) {
                                for(y=0; y<in->HeaderN.y; y++) {
                                        for(z=0; z<in->HeaderN.z; z++) {
@@ -202,6 +214,7 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                        break;
                }
                case lmrcImageNormalizingModeAssumeGaussian: {
+            fprintf(linfo->paramOut, "NormalizingMode: AssumeGaussian\n");
                        mrcImageInformation imageInfo;
                        imageInfo.mode = meanOfAll;
                        lmrcImageInformation(&imageInfo, in);
@@ -214,9 +227,11 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "(mean,sd): %f %f\n", imageInfo.mean, imageInfo.sd);
                        break;
                }
                case lmrcImageNormalizingModeUsingLowValueAreaToHighValueArea: {
+            fprintf(linfo->paramOut, "NormalizingMode: LowValueAreaToHighValueArea\n");
                        mrcImageInformation imageInfo;
                        imageInfo.mode = meanOfLowValueAreaAndHighValueArea;
             imageInfo.thresHigh = linfo->thresOfHighValueArea;
@@ -232,6 +247,9 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                                        }
                                }
                        }
+            fprintf(linfo->paramOut, "thresRate(min,max):  %f %f\n", imageInfo.thresLow, imageInfo.thresHigh);
+            fprintf(linfo->paramOut, "thresValue(min,max): %f %f\n", imageInfo.thresOfLowValueArea, imageInfo.thresOfHighValueArea);
+            fprintf(linfo->paramOut, "value(min,max):      %f %f\n", imageInfo.meanOfLowValueArea, imageInfo.meanOfHighValueArea);
                        break;
                }
                default: {
@@ -240,4 +258,5 @@ lmrcImageNormalizing(mrcImage* out, mrcImage* in, lmrcImageNormalizingInfo* linf
                        break;
                }
        }
+    fprintf(linfo->paramOut, "(A,B):  %f %f\n", linfo->A, linfo->B);
 }

diff --git a/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.h b/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.h
index 975e46f..e6c5b27 100755 (executable)
--- a/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.h
+++ b/src/Objects/DataManip/mrcImage/src/lmrcImageNormalizing.h
@@ -40,6 +40,7 @@ typedef struct lmrcImageNormalizingInfo {
        lmrcImageNormalizingParaTypeReal thresOfLowValueArea;
        lmrcImageNormalizingParaTypeReal thresOfHighValueArea;
        lmrcImageNormalizingMode Mode;
+    FILE* paramOut;
 } lmrcImageNormalizingInfo;
 /* struct end */
 

diff --git a/src/Objects/DataManip/mrcImage/src/mrcImageInfo.c b/src/Objects/DataManip/mrcImage/src/mrcImageInfo.c
index 15c2ea3..210ef29 100755 (executable)
--- a/src/Objects/DataManip/mrcImage/src/mrcImageInfo.c
+++ b/src/Objects/DataManip/mrcImage/src/mrcImageInfo.c
@@ -1082,7 +1082,7 @@ lmrcImageInformation(mrcImageInformation* info, mrcImage* img)
             info->minOfLowValueArea = sort[0];
             info->medianOfLowValueArea = sort[med];
             n = 0;
-            DEBUGPRINT2("thresLow %f %f\n", info->thresLow, sort[thres]); 
+            DEBUGPRINT2("thresLow %f value %f\n", info->thresLow, sort[thres]); 
             DEBUGPRINT6("N %d thres %d med %d  %f %f %f \n", N, thres, med, sort[thres], sort[med], sort[0]); 
             sum = 0;
             for(i=0; i<thres; i++) {

diff --git a/src/Tools/Config/Define.inc b/src/Tools/Config/Define.inc
index ded3357..0605779 100644 (file)
--- a/src/Tools/Config/Define.inc
+++ b/src/Tools/Config/Define.inc
@@ -32,3 +32,10 @@ WORLDNAME=Tools
 WORLDNAME=Tools
 WORLDNAME=Tools
 WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools
+WORLDNAME=Tools

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/Config/OptionControlFile b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/Config/OptionControlFile
index a3a0a15..8815896 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/Config/OptionControlFile
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/Config/OptionControlFile
@@ -2,6 +2,7 @@
 # FileFormat
 "-i","-i[nput]","Input: mrc","Essential","1","1","In","inFile","NULL"
 "-o","-o[utput]","Output: mrc","Essential","1","1","Out","outFile","NULL"
+"-paramo","-param[eter]o[utput]","Output: ASCII","Optional","1","1","OutParams","outFile","stdout"
 "-v","-v[alueForCut]","CutValue/Sigma","Optional","1","1","cutValue","Real","3.0"
 "-u","-u[nsigned]","Unsigned to Signed: Need Max","Optional","2","1","UnsignedMax","Real","65535","2","UnsignedHalf","Real","16384"
 "-thres","-thres","Threshold for Low/High value area ","Optional","1","1","Threshold","Real","0.5"

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/inc/mrcImageAbnormalValueRemove.h b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/inc/mrcImageAbnormalValueRemove.h
index 696be72..ca21eea 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/inc/mrcImageAbnormalValueRemove.h
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/inc/mrcImageAbnormalValueRemove.h
@@ -21,6 +21,10 @@ typedef struct mrcImageAbnormalValueRemoveInfo {
     char* Out;
     FILE* fptOut;
     
+    long flagOutParams;
+    char* OutParams;
+    FILE* fptOutParams;
+    
     long flagcutValue;
     float cutValue;
     

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/argCheck.c b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/argCheck.c
index 8594174..5b9e639 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/argCheck.c
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/argCheck.c
@@ -50,6 +50,17 @@ argCheck(mrcImageAbnormalValueRemoveInfo* info, int argc, char* argv[])
                     }
                     SBREAK;
                 }
+                SCASE("paramo") {
+                    if(i+1<argc) {
+                        info->OutParams = stringGetNthWord(argv[i+1], 1, " ,");
+                        i++;
+                        info->flagOutParams++;
+                    } else {
+                        usage(argv[0]);
+                        exit(EXIT_FAILURE);
+                    }
+                    SBREAK;
+                }
                 SCASE("v") {
                     if(i+1<argc) {
                         info->cutValue = stringGetNthRealData(argv[i+1], 1, " ,");

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/init.c b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/init.c
index 6b2d11e..60cd117 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/init.c
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/init.c
@@ -14,6 +14,7 @@ init0(mrcImageAbnormalValueRemoveInfo* info)
 {
     info->fptIn = NULL;    info->flagIn = 0;
     info->fptOut = NULL;    info->flagOut = 0;
+    info->fptOutParams = stdout;    info->flagOutParams = 0;
     info->cutValue = 3.0;    info->flagcutValue = 0;
     info->UnsignedMax = 65535;    info->flagUnsignedMax = 0;
     info->UnsignedHalf = 16384;    info->flagUnsignedHalf = 0;
@@ -46,6 +47,10 @@ init1(mrcImageAbnormalValueRemoveInfo* info)
         info->fptOut = fileOpen(info->Out, "w");
     }
     
+    if(info->flagOutParams) {
+        info->fptOutParams = fileOpen(info->OutParams, "w");
+    }
+    
     if(info->flagcutValue) {
     }
     

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.c b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.c
index 57eb6fa..5d4c587 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.c
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.c
@@ -17,7 +17,7 @@ static char __sccs_id[] = "%Z%mrcImageAbnormalValueRemove ver%I%; Date:%D% %Z%";
 #define GLOBAL_DECLARATION
 #include "../inc/config.h"
 
-#undef DEBUG
+#define DEBUG
 #include "genUtil.h"
 #include "Random.h"
 #include "mrcImage.h"
@@ -29,6 +29,7 @@ typedef struct lmrcImageAbnormalValueRemoveInfo {
        float UnsignedHalf;
     double Threshold;
     mrcImageInformation ImageInfo;
+    FILE* paramOut;
 } lmrcImageAbnormalValueRemoveInfo;
 
 typedef enum lmrcImageAbnormalValueRemoveMode {
@@ -86,6 +87,9 @@ main(int argc, char* argv[])
        linfo.UnsignedMax = info.UnsignedMax;
        linfo.UnsignedHalf= info.UnsignedHalf;
        linfo.Threshold = info.Threshold;
+
+    linfo.paramOut = info.fptOutParams;
+
        DEBUGPRINT("Program Start\n");
        mrcFileRead(&in, info.In, "in main", 0);
 
@@ -124,7 +128,7 @@ lmrcImageAbnormalValueRemove(mrcImage* out,
 {
     mrcImage tmp;
     mrcImageParaTypeReal x, y, z;
-    double data;
+    double data, dst, tmpD;
 
        if(linfo->flagUnsigned){
                tmp.Header = in->Header;
@@ -135,7 +139,7 @@ lmrcImageAbnormalValueRemove(mrcImage* out,
                for(x=0; x<in->HeaderN.x; x++) {
                        mrcPixelDataGet(in,   x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
                        if(linfo->UnsignedHalf <= data) {
-                               data -= linfo->UnsignedMax;     
+                               data -= linfo->UnsignedMax;
                        }
                }
                }
@@ -148,6 +152,10 @@ lmrcImageAbnormalValueRemove(mrcImage* out,
         case lmrcImageAbnormalValueModeAllArea: {
             linfo->ImageInfo.mode = meanOfAll;
             lmrcImageInformation(&(linfo->ImageInfo), in);
+            fprintf(linfo->paramOut, "AbnormalMode: AllArea\n");
+            fprintf(linfo->paramOut, "ImageInformation(mean,sd):    %g %g\n", linfo->ImageInfo.mean, linfo->ImageInfo.sd);
+            fprintf(linfo->paramOut, "CutValue:                     %g\n", linfo->cutValueOverSigma);
+            fprintf(linfo->paramOut, "NormalArea(mean-sd,mean+sd):  %g %g\n", linfo->ImageInfo.mean-linfo->ImageInfo.sd, linfo->ImageInfo.mean+ linfo->ImageInfo.sd);
             lmrcImageAbnormalValueRemoveAllArea(out, in, linfo, mode); 
             break;
         }
@@ -155,6 +163,11 @@ lmrcImageAbnormalValueRemove(mrcImage* out,
             linfo->ImageInfo.mode = meanOfHighValueArea;
             linfo->ImageInfo.thresHigh = linfo->Threshold;
             lmrcImageInformation(&(linfo->ImageInfo), in);
+            fprintf(linfo->paramOut, "AbnormalMode: HighValueArea\n");
+            fprintf(linfo->paramOut, "ImageInformation(mean,sd):    %g %g\n", linfo->ImageInfo.meanOfHighValueArea, linfo->ImageInfo.sdOfHighValueArea);
+            fprintf(linfo->paramOut, "CutValue:                     %g\n", linfo->cutValueOverSigma);
+            fprintf(linfo->paramOut, "NormalArea(thres,mean+sd):  %g %g\n", linfo->ImageInfo.thresOfHighValueArea,
+                                                                            linfo->ImageInfo.meanOfHighValueArea+linfo->cutValueOverSigma*linfo->ImageInfo.sdOfHighValueArea);
             lmrcImageAbnormalValueRemoveHighValueArea(out, in, linfo, mode); 
             break;
         }
@@ -162,6 +175,11 @@ lmrcImageAbnormalValueRemove(mrcImage* out,
             linfo->ImageInfo.mode = meanOfLowValueArea;
             linfo->ImageInfo.thresLow = linfo->Threshold;
             lmrcImageInformation(&(linfo->ImageInfo), in);
+            fprintf(linfo->paramOut, "AbnormalMode: LowValueArea\n");
+            fprintf(linfo->paramOut, "ImageInformation(mean,sd):    %g %g\n", linfo->ImageInfo.mean, linfo->ImageInfo.sd);
+            fprintf(linfo->paramOut, "CutValue:                     %g\n", linfo->cutValueOverSigma);
+            fprintf(linfo->paramOut, "NormalArea(mean-cutValue*sd,thres):  %g %g\n", linfo->ImageInfo.meanOfLowValueArea-linfo->cutValueOverSigma*linfo->ImageInfo.sdOfLowValueArea, 
+                                                                                     linfo->ImageInfo.thresOfLowValueArea);
             lmrcImageAbnormalValueRemoveLowValueArea(out, in, linfo, mode); 
             break;
         }
@@ -181,7 +199,7 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
        mrcImageInformation inInfo;
        mrcImage tmp;
        mrcImageParaTypeReal x, y, z;
-       double data;
+       double data, dst, tmpD;
 
     inInfo = linfo->ImageInfo;
        switch(mode) {
@@ -190,22 +208,21 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-                               if(data<0) {
-                                       fprintf(stderr, "data is negative: %lf\n", data);
-                               }
                                if(data < inInfo.mean - linfo->cutValueOverSigma*inInfo.sd 
                                  ||      inInfo.mean + linfo->cutValueOverSigma*inInfo.sd < data) {
-                                       data = inInfo.mean + inInfo.sd*randomNormalGet(2);
+                                       dst = inInfo.mean + inInfo.sd*randomNormalGet(2);
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
-                                                       if(data<0) {
-                                                               data = 0;
+                                                       if(dst<0) {
+                                                   DEBUGPRINT1("data is negative: %lf\n", data);
+                                                               dst = 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -250,22 +267,21 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-                               if(data<0) {
-                                       fprintf(stderr, "data is negative: %lf\n", data);
-                               }
                                if(data < mean - linfo->cutValueOverSigma*inInfo.sd
                                  ||      mean + linfo->cutValueOverSigma*inInfo.sd < data) {
-                                       data = mean + SD*randomNormalGet(2);
+                                       dst = mean + SD*randomNormalGet(2);
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
-                                                       if(data<0) {
-                                                               data = 0;
+                                                       if(dst<0) {
+                                                   DEBUGPRINT1("data is negative: %lf\n", data);
+                                                               dst = 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -298,22 +314,21 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-                               if(data<0) {
-                                       fprintf(stderr, "data is negative: %lf\n", data);
-                               }
                                if(data < mean - linfo->cutValueOverSigma*inInfo.sd
                                  ||      mean + linfo->cutValueOverSigma*inInfo.sd < data) {
-                                       data = mean;
+                                       dst = mean;
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
                                                        if(data<0) {
-                                                               data = 0;
+                                                   DEBUGPRINT1("data is negative: %lf\n", data);
+                                                               dst = 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -350,9 +365,9 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                                                for(oy=y-dy; oy<=y+dy; oy++) {
                                                for(ox=x-dx; ox<=x+dx; ox++) {
                                                        if(SQR((ox-x)/dx)+SQR((oy-y)/dy)+SQR((oz-z)/dz)<=1) {
-                                                       mrcPixelDataGet(in, ox, oy, oz, &data, mrcPixelRePart, mrcPixelHowNearest);
-                                                       if( min < data && data < max) {
-                                                                       sum += data;
+                                                       mrcPixelDataGet(in, ox, oy, oz, &tmpD, mrcPixelRePart, mrcPixelHowNearest);
+                                                       if( min < tmpD && tmpD < max) {
+                                                                       sum += tmpD;
                                                                count++;
                                                                }
                                                        }
@@ -361,9 +376,9 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                                                }
                                                if(4<=count) {
                                                        flag ++;
-                                                       data = sum/count;  
-                                                       DEBUGPRINT5("data %f count %d at (%f, %f, %f) \n", data, count, x, y, z);
-                                                       if(data<minHalf || maxHalf < data ) {
+                                                       dst = sum/count;  
+                                                       DEBUGPRINT5("data %f count %d at (%f, %f, %f) \n", dst, count, x, y, z);
+                                                       if(dst < minHalf || maxHalf < dst ) {
                                                                DEBUGPRINT("wider range +1 because of wide abnormal value\n");
                                                                dx++;
                                                                dy++;
@@ -371,7 +386,6 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                                                        } else {
                                                                flag = 4;       
                                                        }
-
                                                } else {
                                                        DEBUGPRINT("wider range +1\n");
                                                        flag=0;
@@ -380,7 +394,7 @@ lmrcImageAbnormalValueRemoveAllArea(mrcImage* out,
                                                        dz++;
                                                }
                                        }
-
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -407,7 +421,7 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
        mrcImageInformation inInfo;
        mrcImage tmp;
        mrcImageParaTypeReal x, y, z;
-       double data;
+       double data, dst, tmpD;
 
     inInfo = linfo->ImageInfo;
        switch(mode) {
@@ -417,17 +431,18 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
                                if(inInfo.meanOfHighValueArea + linfo->cutValueOverSigma*inInfo.sdOfHighValueArea < data) {
-                                       data = inInfo.meanOfHighValueArea + inInfo.sdOfHighValueArea*randomNormalGet(2);
+                                       dst = inInfo.meanOfHighValueArea + inInfo.sdOfHighValueArea*randomNormalGet(2);
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
-                                                       if(data<0) {
-                                                               data = 0;
+                                                       if(dst<0) {
+                                                               dst= 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -443,7 +458,8 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-                               if(inInfo.meanOfHighValueArea + linfo->cutValueOverSigma*inInfo.sdOfHighValueArea < data) {
+                               if( inInfo.thresOfHighValueArea < data && 
+                    data < inInfo.meanOfHighValueArea + linfo->cutValueOverSigma*inInfo.sdOfHighValueArea ) {
                                        sum += data;
                                }
             }
@@ -455,17 +471,18 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
                                if(inInfo.meanOfHighValueArea + linfo->cutValueOverSigma*inInfo.sdOfHighValueArea < data) {
-                                       data = mean;
+                                       dst = mean;
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
-                                                       if(data<0) {
-                                                               data = 0;
+                                                       if(dst <0) {
+                                                               dst = 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
             }
             }
@@ -490,8 +507,7 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-
-                               if(data < min  || max < data) {
+                               if(max < data) {
                                        DEBUGPRINT6("data %f out of range %f <-> %f at (%f, %f, %f) \n", data, min, max, x, y, z);
                                        flag  = 0;
                                        dx = dy = dz = 1;
@@ -502,9 +518,9 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                                                for(oy=y-dy; oy<=y+dy; oy++) {
                                                for(ox=x-dx; ox<=x+dx; ox++) {
                                                        if(SQR((ox-x)/dx)+SQR((oy-y)/dy)+SQR((oz-z)/dz)<=1) {
-                                                       mrcPixelDataGet(in, ox, oy, oz, &data, mrcPixelRePart, mrcPixelHowNearest);
-                                                       if( min < data && data < max) {
-                                                                       sum += data;
+                                                       mrcPixelDataGet(in, ox, oy, oz, &tmpD, mrcPixelRePart, mrcPixelHowNearest);
+                                                       if(tmpD < max) {
+                                                                       sum += tmpD;
                                                                count++;
                                                                }
                                                        }
@@ -513,9 +529,9 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                                                }
                                                if(4<=count) {
                                                        flag ++;
-                                                       data = sum/count;  
+                                                       dst = sum/count;  
                                                        DEBUGPRINT5("data %f count %d at (%f, %f, %f) \n", data, count, x, y, z);
-                                                       if(data<minHalf || maxHalf < data ) {
+                                                       if( maxHalf < data ) {
                                                                DEBUGPRINT("wider range +1 because of wide abnormal value\n");
                                                                dx++;
                                                                dy++;
@@ -523,7 +539,6 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                                                        } else {
                                                                flag = 4;       
                                                        }
-
                                                } else {
                                                        DEBUGPRINT("wider range +1\n");
                                                        flag=0;
@@ -532,7 +547,7 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                                                        dz++;
                                                }
                                        }
-
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -540,7 +555,7 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
             break;
         }
                case lmrcImageAbnormalValueModeRandom: {
-            double sum, mean, sd;
+            double sum, mean, SD;
             int n;
             n=0;
             sum = 0;
@@ -551,6 +566,7 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
                                if(inInfo.thresOfHighValueArea < data 
                  &&data < inInfo.meanOfHighValueArea + linfo->cutValueOverSigma*inInfo.sdOfHighValueArea) {
                     sum += data;
+                    n++;
                                }
             }
             }
@@ -568,11 +584,32 @@ lmrcImageAbnormalValueRemoveHighValueArea(mrcImage* out,
             }
             }
             }
-            sd = sqrt(sum/n);
+            SD = sqrt(sum/n);
             
-
-            break;
-        }
+                       for(z=0; z<in->HeaderN.z; z++) {
+                       for(y=0; y<in->HeaderN.y; y++) {
+                       for(x=0; x<in->HeaderN.x; x++) {
+                               mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
+                               if(mean + linfo->cutValueOverSigma*SD < data) {
+                                       dst = mean + SD*randomNormalGet(2);
+                                       switch(out->HeaderMode) {
+                                               case mrcCharImage:
+                                               case mrcShortImage:
+                                               case mrcLongImage: {
+                                                       if(dst<0) {
+                                                   DEBUGPRINT1("data is negative: %lf\n", data);
+                                                               dst = 0;
+                                                       }
+                                                       break;
+                                               }
+                                       }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
+                               }
+                       }
+                       }
+                       }
+                       break;
+               }
                default: {
                        fprintf(stderr, "Not supported mode: %d\n", mode);
                        exit(EXIT_FAILURE);
@@ -593,7 +630,7 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
        mrcImageInformation inInfo;
        mrcImage tmp;
        mrcImageParaTypeReal x, y, z;
-       double data;
+       double data, dst, tmpD;
 
     inInfo = linfo->ImageInfo;
        switch(mode) {
@@ -603,17 +640,18 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
                                if(data < inInfo.meanOfLowValueArea - linfo->cutValueOverSigma*inInfo.sdOfLowValueArea) {
-                                       data = inInfo.meanOfLowValueArea + inInfo.sdOfLowValueArea*randomNormalGet(2);
+                                       dst = inInfo.meanOfLowValueArea + inInfo.sdOfLowValueArea*randomNormalGet(2);
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
-                                                       if(data<0) {
-                                                               data = 0;
+                                                       if(dst<0) {
+                                                               dst = 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -629,8 +667,10 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-                               if(data < inInfo.meanOfLowValueArea - linfo->cutValueOverSigma*inInfo.sdOfLowValueArea) {
+                               if(inInfo.meanOfLowValueArea - linfo->cutValueOverSigma*inInfo.sdOfLowValueArea < data
+                   && data < inInfo.thresOfLowValueArea ) {
                     sum += data; 
+                    n++;
                                }
                        }
                        }
@@ -641,17 +681,18 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
                                if(data < inInfo.meanOfLowValueArea - linfo->cutValueOverSigma*inInfo.sdOfLowValueArea) {
-                                       data = mean;
+                                       dst = mean;
                                        switch(out->HeaderMode) {
                                                case mrcCharImage:
                                                case mrcShortImage:
                                                case mrcLongImage: {
-                                                       if(data<0) {
-                                                               data = 0;
+                                                       if(dst<0) {
+                                                               dst = 0;
                                                        }
                                                        break;
                                                }
                                        }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
@@ -676,8 +717,7 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
                        for(y=0; y<in->HeaderN.y; y++) {
                        for(x=0; x<in->HeaderN.x; x++) {
                                mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
-
-                               if(data < min  || max < data) {
+                               if(data < min) {
                                        DEBUGPRINT6("data %f out of range %f <-> %f at (%f, %f, %f) \n", data, min, max, x, y, z);
                                        flag  = 0;
                                        dx = dy = dz = 1;
@@ -701,7 +741,7 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
                                                        flag ++;
                                                        data = sum/count;  
                                                        DEBUGPRINT5("data %f count %d at (%f, %f, %f) \n", data, count, x, y, z);
-                                                       if(data<minHalf || maxHalf < data ) {
+                                                       if(data<minHalf) {
                                                                DEBUGPRINT("wider range +1 because of wide abnormal value\n");
                                                                dx++;
                                                                dy++;
@@ -718,14 +758,69 @@ lmrcImageAbnormalValueRemoveLowValueArea(mrcImage* out,
                                                        dz++;
                                                }
                                        }
-
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
+                               }
+                       }
+                       }
+                       }
+            break;
+        }
+               case lmrcImageAbnormalValueModeRandom: {
+            double sum, mean, SD;
+            int n;
+            n=0;
+            sum = 0;
+                       for(z=0; z<in->HeaderN.z; z++) {
+                       for(y=0; y<in->HeaderN.y; y++) {
+                       for(x=0; x<in->HeaderN.x; x++) {
+                               mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
+                               if(data < inInfo.thresOfLowValueArea 
+                 &&inInfo.meanOfLowValueArea - linfo->cutValueOverSigma*inInfo.sdOfLowValueArea < data) {
+                    sum += data;
+                    n++;
+                               }
+            }
+            }
+            }
+            mean = sum/n;
+            sum = 0;
+                       for(z=0; z<in->HeaderN.z; z++) {
+                       for(y=0; y<in->HeaderN.y; y++) {
+                       for(x=0; x<in->HeaderN.x; x++) {
+                               mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
+                               if(data < inInfo.thresOfLowValueArea 
+                 &&inInfo.meanOfLowValueArea - linfo->cutValueOverSigma*inInfo.sdOfLowValueArea  <data) {
+                    sum += SQR(data-mean);
+                               }
+            }
+            }
+            }
+            SD = sqrt(sum/n);
+            
+                       for(z=0; z<in->HeaderN.z; z++) {
+                       for(y=0; y<in->HeaderN.y; y++) {
+                       for(x=0; x<in->HeaderN.x; x++) {
+                               mrcPixelDataGet(in, x, y, z, &data, mrcPixelRePart, mrcPixelHowNearest);
+                               if(data < mean - linfo->cutValueOverSigma*SD) {
+                                       dst = mean + SD*randomNormalGet(2);
+                                       switch(out->HeaderMode) {
+                                               case mrcCharImage:
+                                               case mrcShortImage:
+                                               case mrcLongImage: {
+                                                       if(dst<0) {
+                                                   DEBUGPRINT1("data is negative: %lf\n", data);
+                                                               dst = 0;
+                                                       }
+                                                       break;
+                                               }
+                                       }
+                    fprintf(linfo->paramOut,"AbnormalValue: %f -> %f at %f %f %f\n", data, dst, x, y, z); 
                                }
                        }
                        }
                        }
             break;
         }
-               case lmrcImageAbnormalValueModeRandom: 
                default: {
                        fprintf(stderr, "Not supported mode: %d\n", mode);
                        exit(EXIT_FAILURE);

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.html b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.html
index 0bf59a5..212ae1f 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.html
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.html
@@ -10,6 +10,7 @@ Usage: mrcImageAbnormalValueRemove
 Options:
     [-i[nput]            In                  (NULL      ).as(inFile              ) ] :Essential :Input: mrc
     [-o[utput]           Out                 (NULL      ).as(outFile             ) ] :Essential :Output: mrc
+    [-param[eter]o[utput]OutParams           (stdout    ).as(outFile             ) ] :Optional  :Output: ASCII
     [-v[alueForCut]      cutValue            (3.0       ).as(Real                ) ] :Optional  :CutValue/Sigma
     [-u[nsigned]         UnsignedMax         (65535     ).as(Real                ) 
                          UnsignedHalf        (16384     ).as(Real                ) ] :Optional  :Unsigned to Signed: Need Max

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.pane b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.pane
index e83dc30..901a18d 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.pane
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/mrcImageAbnormalValueRemove.pane
@@ -9,12 +9,13 @@
         -Q 1 0 5.25x1+47+0 'Close'
         -I 1 0 1 1 0 1 -1x1+1+1.500000 ' ' 'In' 'Input: mrc' i
         -O 1 0 1 1 0 1 -1x1+1+3.000000 ' ' 'Out' 'Output: mrc' o
-        -f 1 0 1 0 0 -1x1+1+4.500000 0 0 3.000000 0 0 0 'cutValue' 'CutValue/Sigma' v
-        -I  1 0 0 1 0 1 -1x1+1+6 ' ' '65535' 'UnsignedMax' Unsigned to Signed: Need Max
-        -f 1 0 1 0 0 -1x1+1+7.500000 0 0 0.500000 0 0 0 'Threshold' 'Threshold for Low/High value area ' thres
-        -I 1 0 1 0 0 1 -1x1+1+9.000000 ' ' 'configFile' 'ConfigurationFile' c
-        -i 1 0 1 0 0 -1x1+1+10.500000 0 0 0 0 0 'Pattern' 'Mode2:AbnormalPattern' P
-        -i 1 0 1 0 0 -1x1+1+12.000000 0 0 0 0 0 'mode' 'Mode' m
+        -O 1 0 1 0 0 1 -1x1+1+4.500000 ' ' 'OutParams' 'Output: ASCII' paramo
+        -f 1 0 1 0 0 -1x1+1+6.000000 0 0 3.000000 0 0 0 'cutValue' 'CutValue/Sigma' v
+        -I  1 0 0 1 0 1 -1x1+1+7 ' ' '65535' 'UnsignedMax' Unsigned to Signed: Need Max
+        -f 1 0 1 0 0 -1x1+1+9.000000 0 0 0.500000 0 0 0 'Threshold' 'Threshold for Low/High value area ' thres
+        -I 1 0 1 0 0 1 -1x1+1+10.500000 ' ' 'configFile' 'ConfigurationFile' c
+        -i 1 0 1 0 0 -1x1+1+12.000000 0 0 0 0 0 'Pattern' 'Mode2:AbnormalPattern' P
+        -i 1 0 1 0 0 -1x1+1+13.500000 0 0 0 0 0 'mode' 'Mode' m
     -E
   -E
 -E

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/test/Makefile b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/test/Makefile
index b3d2db8..225d270 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/test/Makefile
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/test/Makefile
@@ -11,12 +11,15 @@ help:
 
 exec:
        @echo "----- Execution Check -----"
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.0.0.nor -m 0 -P 0  
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.0.1.nor -m 0 -P 1 -thres 0.9
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.0.2.nor -m 0 -P 2 -thres 0.1
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.2.0.nor -m 2 -P 0  
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.2.1.nor -m 2 -P 1 -thres 0.9
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.2.2.nor -m 2 -P 2 -thres 0.1
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.0.0.nor -m 0 -P 0               -paramo data/test.0.0.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.0.1.nor -m 0 -P 1 -thres 0.9999 -paramo data/test.0.1.param 
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.0.2.nor -m 0 -P 2 -thres 0.01   -paramo data/test.0.2.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.1.0.nor -m 1 -P 0               -paramo data/test.1.0.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.1.1.nor -m 1 -P 1 -thres 0.9999 -paramo data/test.1.1.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.1.2.nor -m 1 -P 2 -thres 0.01   -paramo data/test.1.2.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.2.0.nor -m 2 -P 0               -paramo data/test.2.0.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.2.1.nor -m 2 -P 1 -thres 0.9999 -paramo data/test.2.1.param
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/test.nor -o data/test.2.2.nor -m 2 -P 2 -thres 0.01   -paramo data/test.2.2.param
        @echo "----- Calc check -----"          
 
 clean:

diff --git a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/usage.c b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/usage.c
index 6c8e481..e413c5a 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/usage.c
+++ b/src/Tools/mrcImage/mrcImageAbnormalValueRemove/src/usage.c
@@ -9,6 +9,7 @@ usage(char* thisProgram)
     fprintf(stderr, "Options:\n");
     fprintf(stderr, "    [-i[nput]            In                  (NULL      ).as(inFile              ) ] :Essential :Input: mrc\n");
     fprintf(stderr, "    [-o[utput]           Out                 (NULL      ).as(outFile             ) ] :Essential :Output: mrc\n");
+    fprintf(stderr, "    [-param[eter]o[utput]OutParams           (stdout    ).as(outFile             ) ] :Optional  :Output: ASCII\n");
     fprintf(stderr, "    [-v[alueForCut]      cutValue            (3.0       ).as(Real                ) ] :Optional  :CutValue/Sigma\n");
     fprintf(stderr, "    [-u[nsigned]         UnsignedMax         (65535     ).as(Real                ) \n                         UnsignedHalf        (16384     ).as(Real                ) ] :Optional  :Unsigned to Signed: Need Max\n");
     fprintf(stderr, "    [-thres              Threshold           (0.5       ).as(Real                ) ] :Optional  :Threshold for Low/High value area \n");

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/Config/OptionControlFile b/src/Tools/mrcImage/mrcImageNormalizing/Config/OptionControlFile
index 151b7fd..7f31b51 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/Config/OptionControlFile
+++ b/src/Tools/mrcImage/mrcImageNormalizing/Config/OptionControlFile
@@ -9,5 +9,6 @@
 "-ContourSolvent","-ContourSolvent","ContourSolvent","Optional","1","1","ContourSolvent","Real","0.0"
 "-Low","-Low[ValueArea]","LowValueArea: rate","Optional","1","1","thresOfLowValueArea","Real","0.1"
 "-High","-High[ValueArea]","HighValueArea: rate","Optional","1","1","thresOfHighValueArea","Real","0.9"
+"-paramo","-param[eter]o[utput]","ConfigurationFile","Optional","1","1","ParamOut","outFile","stdout"
 "-c","-c[onfig]","ConfigurationFile","Optional","1","1","configFile","inFile","NULL"
 "-m","-m[ode]","Mode","Optional","1","1","mode","Integer","0"

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/inc/mrcImageNormalizing.h b/src/Tools/mrcImage/mrcImageNormalizing/inc/mrcImageNormalizing.h
index bb6c2a7..e3ae65b 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/inc/mrcImageNormalizing.h
+++ b/src/Tools/mrcImage/mrcImageNormalizing/inc/mrcImageNormalizing.h
@@ -42,6 +42,10 @@ typedef struct mrcImageNormalizingInfo {
     long flagthresOfHighValueArea;
     float thresOfHighValueArea;
     
+    long flagParamOut;
+    char* ParamOut;
+    FILE* fptParamOut;
+    
     long flagconfigFile;
     char* configFile;
     FILE* fptconfigFile;

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/argCheck.c b/src/Tools/mrcImage/mrcImageNormalizing/src/argCheck.c
index 1eee40f..de50e81 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/argCheck.c
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/argCheck.c
@@ -127,6 +127,17 @@ argCheck(mrcImageNormalizingInfo* info, int argc, char* argv[])
                     }
                     SBREAK;
                 }
+                SCASE("paramo") {
+                    if(i+1<argc) {
+                        info->ParamOut = stringGetNthWord(argv[i+1], 1, " ,");
+                        i++;
+                        info->flagParamOut++;
+                    } else {
+                        usage(argv[0]);
+                        exit(EXIT_FAILURE);
+                    }
+                    SBREAK;
+                }
                 SCASE("c") {
                     if(i+1<argc) {
                         info->configFile = stringGetNthWord(argv[i+1], 1, " ,");

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/init.c b/src/Tools/mrcImage/mrcImageNormalizing/src/init.c
index 28d5c14..b7fce0d 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/init.c
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/init.c
@@ -21,6 +21,7 @@ init0(mrcImageNormalizingInfo* info)
     info->ContourSolvent = 0.0;    info->flagContourSolvent = 0;
     info->thresOfLowValueArea = 0.1;    info->flagthresOfLowValueArea = 0;
     info->thresOfHighValueArea = 0.9;    info->flagthresOfHighValueArea = 0;
+    info->fptParamOut = stdout;    info->flagParamOut = 0;
     info->fptconfigFile = NULL;    info->flagconfigFile = 0;
     info->mode = 0;    info->flagmode = 0;
 }
@@ -69,6 +70,10 @@ init1(mrcImageNormalizingInfo* info)
     if(info->flagthresOfHighValueArea) {
     }
     
+    if(info->flagParamOut) {
+        info->fptParamOut = fileOpen(info->ParamOut, "w");
+    }
+    
     if(info->flagconfigFile) {
         info->fptconfigFile = fileOpen(info->configFile, "r");
     }

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.c b/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.c
index e470bc1..db74d6b 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.c
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.c
@@ -44,9 +44,12 @@ main(int argc, char* argv[])
     linfo.thresOfLowValueArea  = info.thresOfLowValueArea;
     linfo.thresOfHighValueArea = info.thresOfHighValueArea;
        linfo.Mode = info.mode;
-       
+    linfo.paramOut = info.fptParamOut; 
+
        lmrcImageNormalizing(&out, &in, &linfo, 0);
 
+    mrcStatDataSet(&out, 0);
+    fprintf(linfo.paramOut, "Nor(min,mean,max): %f %f %f\n", out.HeaderAMin, out.HeaderAMean, out.HeaderAMax);
        mrcFileWrite(&out, info.Out, "from main", 0);
 
        exit(EXIT_SUCCESS);

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.html b/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.html
index e39cf82..f167c60 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.html
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.html
@@ -17,6 +17,7 @@ Options:
     [-ContourSolvent     ContourSolvent      (0.0       ).as(Real                ) ] :Optional  :ContourSolvent
     [-Low[ValueArea]     thresOfLowValueArea (0.1       ).as(Real                ) ] :Optional  :LowValueArea: rate
     [-High[ValueArea]    thresOfHighValueArea(0.9       ).as(Real                ) ] :Optional  :HighValueArea: rate
+    [-param[eter]o[utput]ParamOut            (stdout    ).as(outFile             ) ] :Optional  :ConfigurationFile
     [-c[onfig]           configFile          (NULL      ).as(inFile              ) ] :Optional  :ConfigurationFile
     [-m[ode]             mode                (0         ).as(Integer             ) ] :Optional  :Mode
 ----- mode -----

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.pane b/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.pane
index 271dbe0..7ffff90 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.pane
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/mrcImageNormalizing.pane
@@ -16,8 +16,9 @@
         -f 1 0 1 0 0 -1x1+1+10.500000 0 0 0.000000 0 0 0 'ContourSolvent' 'ContourSolvent' ContourSolvent
         -f 1 0 1 0 0 -1x1+1+12.000000 0 0 0.100000 0 0 0 'thresOfLowValueArea' 'LowValueArea: rate' Low
         -f 1 0 1 0 0 -1x1+1+13.500000 0 0 0.900000 0 0 0 'thresOfHighValueArea' 'HighValueArea: rate' High
-        -I 1 0 1 0 0 1 -1x1+1+15.000000 ' ' 'configFile' 'ConfigurationFile' c
-        -i 1 0 1 0 0 -1x1+1+16.500000 0 0 0 0 0 'mode' 'Mode' m
+        -O 1 0 1 0 0 1 -1x1+1+15.000000 ' ' 'ParamOut' 'ConfigurationFile' paramo
+        -I 1 0 1 0 0 1 -1x1+1+16.500000 ' ' 'configFile' 'ConfigurationFile' c
+        -i 1 0 1 0 0 -1x1+1+18.000000 0 0 0 0 0 'mode' 'Mode' m
     -E
   -E
 -E

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/test/Makefile b/src/Tools/mrcImage/mrcImageNormalizing/src/test/Makefile
index e6c856d..09a3b75 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/test/Makefile
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/test/Makefile
@@ -11,8 +11,8 @@ help:
 
 exec:
        @echo "----- Execution Check -----"
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/121p-GC.mrc3d -o data/121p-GC.mode5.mrc3d -m 5 -A 1 -B 0  
-       ../$(OSTYPE)/$(OBJECTNAME) -i data/121p-GC.mrc3d -o data/121p-GC.mode7.mrc3d -m 7 -Low 0.1 -High 0.99  -A 0.9 -B 0.1   
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/121p-GC.mrc3d -o data/121p-GC.mode5.mrc3d -m 5 -A 1 -B 0   -paramo data/121p-GC.mode5.mrc3d.param 
+       ../$(OSTYPE)/$(OBJECTNAME) -i data/121p-GC.mrc3d -o data/121p-GC.mode7.mrc3d -m 7 -Low 0.1 -High 0.99  -A 0.9 -B 0.1  -paramo data/121p-GC.mode7.mrc3d.param 
        @echo "----- Calc check -----"          
 
 init:

diff --git a/src/Tools/mrcImage/mrcImageNormalizing/src/usage.c b/src/Tools/mrcImage/mrcImageNormalizing/src/usage.c
index b800727..9fb21f3 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageNormalizing/src/usage.c
+++ b/src/Tools/mrcImage/mrcImageNormalizing/src/usage.c
@@ -16,6 +16,7 @@ usage(char* thisProgram)
     fprintf(stderr, "    [-ContourSolvent     ContourSolvent      (0.0       ).as(Real                ) ] :Optional  :ContourSolvent\n");
     fprintf(stderr, "    [-Low[ValueArea]     thresOfLowValueArea (0.1       ).as(Real                ) ] :Optional  :LowValueArea: rate\n");
     fprintf(stderr, "    [-High[ValueArea]    thresOfHighValueArea(0.9       ).as(Real                ) ] :Optional  :HighValueArea: rate\n");
+    fprintf(stderr, "    [-param[eter]o[utput]ParamOut            (stdout    ).as(outFile             ) ] :Optional  :ConfigurationFile\n");
     fprintf(stderr, "    [-c[onfig]           configFile          (NULL      ).as(inFile              ) ] :Optional  :ConfigurationFile\n");
     fprintf(stderr, "    [-m[ode]             mode                (0         ).as(Integer             ) ] :Optional  :Mode\n");
     additionalUsage();

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/inc/mrcImageSeriesNormalizing.h b/src/Tools/mrcImage/mrcImageSeriesNormalizing/inc/mrcImageSeriesNormalizing.h
index 25adf1d..9dde98f 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/inc/mrcImageSeriesNormalizing.h
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/inc/mrcImageSeriesNormalizing.h
@@ -71,6 +71,10 @@ typedef struct mrcImageSeriesNormalizingInfo {
     long flagftol;
     float ftol;
     
+    long flagParamOut;
+    char* ParamOut;
+    FILE* fptParamOut;
+    
     long flagconfigFile;
     char* configFile;
     FILE* fptconfigFile;

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/argCheck.c b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/argCheck.c
index 2154ee7..01aeec5 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/argCheck.c
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/argCheck.c
@@ -183,6 +183,17 @@ argCheck(mrcImageSeriesNormalizingInfo* info, int argc, char* argv[])
                     }
                     SBREAK;
                 }
+                SCASE("paramo") {
+                    if(i+1<argc) {
+                        info->ParamOut = stringGetNthWord(argv[i+1], 1, " ,");
+                        i++;
+                        info->flagParamOut++;
+                    } else {
+                        usage(argv[0]);
+                        exit(EXIT_FAILURE);
+                    }
+                    SBREAK;
+                }
                 SCASE("c") {
                     if(i+1<argc) {
                         info->configFile = stringGetNthWord(argv[i+1], 1, " ,");

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/init.c b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/init.c
index 1bccaca..a7724a9 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/init.c
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/init.c
@@ -29,6 +29,7 @@ init0(mrcImageSeriesNormalizingInfo* info)
     info->xtol = 1e-8;    info->flagxtol = 0;
     info->gtol = 1e-8;    info->flaggtol = 0;
     info->ftol = 0.0;    info->flagftol = 0;
+    info->fptParamOut = stdout;    info->flagParamOut = 0;
     info->fptconfigFile = NULL;    info->flagconfigFile = 0;
     info->mode = 0;    info->flagmode = 0;
 }
@@ -132,6 +133,10 @@ init1(mrcImageSeriesNormalizingInfo* info)
     if(info->flagftol) {
     }
     
+    if(info->flagParamOut) {
+        info->fptParamOut = fileOpen(info->ParamOut, "w");
+    }
+    
     if(info->flagconfigFile) {
         info->fptconfigFile = fileOpen(info->configFile, "r");
     }

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.c b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.c
index 26e72ea..0d27a53 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.c
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.c
@@ -32,6 +32,7 @@ typedef struct lmrcImageSeriesNormalizingInfo {
     eosNonLinearFittingParams outHigh;
     eosNonLinearFittingParams outLow;
     int maxIter;
+    FILE* paramOut;
 } lmrcImageSeriesNormalizingInfo;
 
 typedef enum lmrcImageSeriesNormalizingMode {
@@ -74,6 +75,8 @@ main(int argc, char* argv[])
     if(info.flagIn!=info.flagOut) {
         fprintf(stderr, "In num %ld is diffrenct from Out num %ld\n", info.flagIn, info.flagOut);
     }
+    linfo.paramOut = info.fptParamOut;
+    
     in  = (mrcImage*)memoryAllocate(sizeof(mrcImage)*info.flagIn, "in main"); 
     out = (mrcImage*)memoryAllocate(sizeof(mrcImage)*info.flagOut, "in main"); 
 
@@ -86,6 +89,8 @@ main(int argc, char* argv[])
     lmrcImageSeriesNormalizingOutputParam(info.fptParam, linfo, info.mode);
 
     for(i=0; i<info.flagOut; i++) {
+        mrcStatDataSet(&(out[i]), 0); 
+        fprintf(info.fptParam, "(name,min,mean,max): %s %f %f %f\n", info.Out[i], out[i].HeaderAMin, out[i].HeaderAMean, out[i].HeaderAMax);
         mrcFileWrite(&(out[i]), info.Out[i], "in main", 0);
     }    
 

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.html b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.html
old mode 100644 (file)
new mode 100755 (executable)
index 6791072..4abd489
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.html
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.html
@@ -25,6 +25,7 @@ Options:
     [-xtol               xtol                (1e-8      ).as(Real                ) ] :Optional  :xtol
     [-gtol               gtol                (1e-8      ).as(Real                ) ] :Optional  :gtol
     [-ftol               ftol                (0.0       ).as(Real                ) ] :Optional  :ftol
+    [-param[eter]o[out]  ParamOut            (stdout    ).as(outFile             ) ] :Optional  :parameterFile
     [-c[onfig]           configFile          (NULL      ).as(inFile              ) ] :Optional  :ConfigurationFile
     [-m[ode]             mode                (0         ).as(Integer             ) ] :Optional  :Mode
 ----- Additional Usage -----

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.pane b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.pane
index f143a76..b6cedc3 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.pane
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/mrcImageSeriesNormalizing.pane
@@ -20,8 +20,9 @@
         -f 1 0 1 0 0 -1x1+1+16.500000 0 0 0.000000 0 0 0 'xtol' 'xtol' xtol
         -f 1 0 1 0 0 -1x1+1+18.000000 0 0 0.000000 0 0 0 'gtol' 'gtol' gtol
         -f 1 0 1 0 0 -1x1+1+19.500000 0 0 0.000000 0 0 0 'ftol' 'ftol' ftol
-        -I 1 0 1 0 0 1 -1x1+1+21.000000 ' ' 'configFile' 'ConfigurationFile' c
-        -i 1 0 1 0 0 -1x1+1+22.500000 0 0 0 0 0 'mode' 'Mode' m
+        -O 1 0 1 0 0 1 -1x1+1+21.000000 ' ' 'ParamOut' 'parameterFile' paramo
+        -I 1 0 1 0 0 1 -1x1+1+22.500000 ' ' 'configFile' 'ConfigurationFile' c
+        -i 1 0 1 0 0 -1x1+1+24.000000 0 0 0 0 0 'mode' 'Mode' m
     -E
   -E
 -E

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/test/Makefile b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/test/Makefile
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/test/test.init b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/test/test.init
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/usage.c b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/usage.c
index 2690ffe..1f01897 100755 (executable)
--- a/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/usage.c
+++ b/src/Tools/mrcImage/mrcImageSeriesNormalizing/src/usage.c
@@ -20,6 +20,7 @@ usage(char* thisProgram)
     fprintf(stderr, "    [-xtol               xtol                (1e-8      ).as(Real                ) ] :Optional  :xtol\n");
     fprintf(stderr, "    [-gtol               gtol                (1e-8      ).as(Real                ) ] :Optional  :gtol\n");
     fprintf(stderr, "    [-ftol               ftol                (0.0       ).as(Real                ) ] :Optional  :ftol\n");
+    fprintf(stderr, "    [-param[eter]o[out]  ParamOut            (stdout    ).as(outFile             ) ] :Optional  :parameterFile\n");
     fprintf(stderr, "    [-c[onfig]           configFile          (NULL      ).as(inFile              ) ] :Optional  :ConfigurationFile\n");
     fprintf(stderr, "    [-m[ode]             mode                (0         ).as(Integer             ) ] :Optional  :Mode\n");
     additionalUsage();