testing witgh Eyesis

src/main/java/EyesisCorrectionParameters.java

@@ -101,7 +101,7 @@ public class EyesisCorrectionParameters {
     	public boolean planeAsJPEG=       true;   // save de-warped image as JPEG (only if equirectangularFormat==0)
 //    	public String equirectangularSuffixA="A.eqr-tiff"; // or the roll-over part
     	public String resultsDirectory="";
-    	public boolean removeUnusedSensorData=true;
+    	public boolean removeUnusedSensorData=false;
     	public int exposureCorrectionMode=2; // - 0 - none, 1 - absolute, 2 - relative
     	public double referenceExposure=0.0003; // 3/10000 sec, used in absolute mode only
     	public double relativeExposure=0.5; // 0.0 - use shortest (darken), 1.0 - use longest (brighten)
@@ -1795,7 +1795,6 @@ public class EyesisCorrectionParameters {
   		public double decimateSigma =   -1.0; // special mode for 2:1 deciamtion 
   		public int    tileX =            82;  // number of kernel tile (0..163) 
   		public int    tileY =            62;  // number of kernel tile (0..122) 
-  		public boolean subtract_dc =     false;// subtract/restore dc
   		public int    kernel_chn =      -1; // camera channel calibration to use for aberration correction ( < 0 - no correction)
   		public boolean normalize =       true; // normalize both sym and asym kernels (asym to have sum==1, sym to have sum = dct_size
   		public boolean normalize_sym =   true; // normalize sym kernels separately
@@ -1808,6 +1807,10 @@ public class EyesisCorrectionParameters {
   		public double novignetting_g    = 0.3733; // green gain in the center of sensor calibration G
   		public double novignetting_b    = 0.2034; // blue gain in the center of sensor calibration B
   		
+  		public double scale_r =           1.0; // extra gain correction after vignetting or nonvignetting, before other processing
+  		public double scale_g =           1.0;
+  		public double scale_b =           1.0;
+  		
   		public double vignetting_max    = 0.4; // value in vignetting data to correspond to 1x in the kernel
   		public double vignetting_range  = 5.0; // do not try to correct vignetting less than vignetting_max/vignetting_range
   		
@@ -1877,7 +1880,6 @@ public class EyesisCorrectionParameters {
   			properties.setProperty(prefix+"decimateSigma",      this.decimateSigma+"");
   			properties.setProperty(prefix+"tileX",              this.tileX+"");
   			properties.setProperty(prefix+"tileY",              this.tileY+"");
-  			properties.setProperty(prefix+"subtract_dc",   this.subtract_dc+"");
   			properties.setProperty(prefix+"kernel_chn",         this.kernel_chn+"");
   			properties.setProperty(prefix+"normalize",          this.normalize+"");
   			properties.setProperty(prefix+"normalize_sym",      this.normalize_sym+"");
@@ -1889,6 +1891,12 @@ public class EyesisCorrectionParameters {
   			properties.setProperty(prefix+"novignetting_g",     this.novignetting_g+"");
   			properties.setProperty(prefix+"novignetting_b",     this.novignetting_b+"");
   			
+  			
+  			properties.setProperty(prefix+"scale_r",            this.scale_r+"");
+  			properties.setProperty(prefix+"scale_g",            this.scale_g+"");
+  			properties.setProperty(prefix+"scale_b",            this.scale_b+"");
+  			
+  			
   			properties.setProperty(prefix+"vignetting_max",     this.vignetting_max+"");
   			properties.setProperty(prefix+"vignetting_range",   this.vignetting_range+"");
   			properties.setProperty(prefix+"color_DCT",          this.color_DCT+"");
@@ -1941,7 +1949,6 @@ public class EyesisCorrectionParameters {
   			if (properties.getProperty(prefix+"tileX")!=null) this.tileX=Integer.parseInt(properties.getProperty(prefix+"tileX"));
   			if (properties.getProperty(prefix+"tileY")!=null) this.tileY=Integer.parseInt(properties.getProperty(prefix+"tileY"));
   			if (properties.getProperty(prefix+"dbg_window_mode")!=null) this.dbg_window_mode=Integer.parseInt(properties.getProperty(prefix+"dbg_window_mode"));
-  			if (properties.getProperty(prefix+"subtract_dc")!=null) this.subtract_dc=Boolean.parseBoolean(properties.getProperty(prefix+"subtract_dc"));
   			if (properties.getProperty(prefix+"kernel_chn")!=null) this.kernel_chn=Integer.parseInt(properties.getProperty(prefix+"kernel_chn"));
   			if (properties.getProperty(prefix+"normalize")!=null) this.normalize=Boolean.parseBoolean(properties.getProperty(prefix+"normalize"));
   			if (properties.getProperty(prefix+"normalize_sym")!=null) this.normalize_sym=Boolean.parseBoolean(properties.getProperty(prefix+"normalize_sym"));
@@ -1953,6 +1960,11 @@ public class EyesisCorrectionParameters {
   			if (properties.getProperty(prefix+"novignetting_g")!=null) this.novignetting_g=Double.parseDouble(properties.getProperty(prefix+"novignetting_g"));
   			if (properties.getProperty(prefix+"novignetting_b")!=null) this.novignetting_b=Double.parseDouble(properties.getProperty(prefix+"novignetting_b"));
   			
+  			if (properties.getProperty(prefix+"scale_r")!=null)        this.scale_r=Double.parseDouble(properties.getProperty(prefix+"scale_r"));
+  			if (properties.getProperty(prefix+"scale_g")!=null)        this.scale_g=Double.parseDouble(properties.getProperty(prefix+"scale_g"));
+  			if (properties.getProperty(prefix+"scale_b")!=null)        this.scale_b=Double.parseDouble(properties.getProperty(prefix+"scale_b"));
+
+  			
   			if (properties.getProperty(prefix+"vignetting_max")!=null) this.vignetting_max=Double.parseDouble(properties.getProperty(prefix+"vignetting_max"));
   			if (properties.getProperty(prefix+"vignetting_range")!=null) this.vignetting_range=Double.parseDouble(properties.getProperty(prefix+"vignetting_range"));
   			if (properties.getProperty(prefix+"color_DCT")!=null)      this.color_DCT=Boolean.parseBoolean(properties.getProperty(prefix+"color_DCT"));
@@ -2004,7 +2016,6 @@ public class EyesisCorrectionParameters {
   			gd.addNumericField("Smooth convolution kernel before decimation",                    this.decimateSigma,       3);
   			gd.addNumericField("Tile X to extract (0..163)",                                     this.tileX,               0);
   			gd.addNumericField("Tile Y to extract (0..122)",                                     this.tileY,               0);
-  			gd.addCheckbox    ("Subtract avarege before dct, restore after idct",                this.subtract_dc);
   			gd.addNumericField("Calibration channel to use for aberration ( <0 - no correction)",this.kernel_chn,          0);
   			gd.addCheckbox    ("Normalize both sym and asym kernels ",                           this.normalize);
   			gd.addCheckbox    ("Normalize sym kernels separately",                               this.normalize_sym);
@@ -2016,9 +2027,13 @@ public class EyesisCorrectionParameters {
   			gd.addNumericField("Green gain in the center of sensor calibration G (instead of vignetting)",this.novignetting_g, 4);
   			gd.addNumericField("Blue gain in the center of sensor calibration B (instead of vignetting)",this.novignetting_b,  4);
 
-  			gd.addNumericField("Value (max) in vignetting data to correspond to 1x in the kernel",this.vignetting_max,      3);
-  			gd.addNumericField("Do not try to correct vignetting smaller than this fraction of max",this.vignetting_range,  3);
-  			gd.addCheckbox    ("Use DCT-base color conversion",                                   this.color_DCT             );
+  			gd.addNumericField("Extra red correction to compensate for light temperature",               this.scale_r,  4);
+  			gd.addNumericField("Extra green correction to compensate for light temperature",             this.scale_g,  4);
+  			gd.addNumericField("Extra blue correction to compensate for light temperature",              this.scale_b,  4);
+  			
+  			gd.addNumericField("Value (max) in vignetting data to correspond to 1x in the kernel",    this.vignetting_max,      3);
+  			gd.addNumericField("Do not try to correct vignetting smaller than this fraction of max",  this.vignetting_range,  3);
+  			gd.addCheckbox    ("Use DCT-based color conversion (false - just LPF RGB with dbg_sigma)",this.color_DCT             );
   			gd.addNumericField("Gaussian sigma to apply to R and B (in addition to G), pix",      this.sigma_rb,            3);
   			gd.addNumericField("Gaussian sigma to apply to Y in the MDCT domain, pix",            this.sigma_y,             3);
   			gd.addNumericField("Gaussian sigma to apply to Pr and Pb in the MDCT domain, pix",    this.sigma_color,         3);
@@ -2067,7 +2082,6 @@ public class EyesisCorrectionParameters {
   			this.decimateSigma=         gd.getNextNumber();
   			this.tileX=           (int) gd.getNextNumber();
   			this.tileY=           (int) gd.getNextNumber();
-  			this.subtract_dc=           gd.getNextBoolean();
   			this.kernel_chn=      (int) gd.getNextNumber();
   			this.normalize=             gd.getNextBoolean();
   			this.normalize_sym=         gd.getNextBoolean();
@@ -2077,6 +2091,12 @@ public class EyesisCorrectionParameters {
   			this.novignetting_r=        gd.getNextNumber();
   			this.novignetting_g=        gd.getNextNumber();
   			this.novignetting_b=        gd.getNextNumber();
+
+  			this.scale_r=               gd.getNextNumber();
+  			this.scale_g=               gd.getNextNumber();
+  			this.scale_b=               gd.getNextNumber();
+  			
+  			
   			this.vignetting_max=        gd.getNextNumber();
   			this.vignetting_range=      gd.getNextNumber();
   			this.color_DCT=             gd.getNextBoolean();

src/main/java/EyesisCorrections.java

@@ -107,16 +107,6 @@ public class EyesisCorrections {
 		//if ((this.debugLevel>1) && (correctionsParameters.sourcePaths!=null) && (correctionsParameters.sourcePaths.length>0)) {
 		if ((this.debugLevel>101) && (correctionsParameters.sourcePaths!=null) && (correctionsParameters.sourcePaths.length>0)) {
 			testFF(correctionsParameters.sourcePaths[0]);
-//			this.channelVignettingCorrection[srcChannel]=this.pixelMapping.getBayerFlatFieldFloat(
-/*			
-			SDFA_INSTANCE.showArrays(
-					this.channelVignettingCorrection,
-					this.channelWidthHeight[srcChannel][0],
-					this.channelWidthHeight[srcChannel][1],
-					true,
-					"Flat-Field");
-					//LENS_DISTORTIONS.displayGridTitles());
-*/
 		}
 		
 	}

src/main/java/EyesisDCT.java

@@ -30,7 +30,6 @@ import ij.ImagePlus;
 import ij.ImageStack;
 import ij.Prefs;
 import ij.io.FileSaver;
-import ij.process.FloatProcessor;
 import ij.process.ImageProcessor;
 
 
@@ -220,16 +219,7 @@ public class EyesisDCT {
 		  final int preTargetSize = 4 * dct_size; 
 		  final int targetSize =    2 * dct_size; // normally 16
 		  final double [] anitperiodic_window = createAntiperiodicWindow(dct_size);
-/*		  
-		  final int vgn_step =   dct_kernel.img_step/vign_decimation;
-		  final int vgn_width =  vign_width/vign_decimation;
-		  final int vgn_height = vign_height/vign_decimation;
-		  final int vgn_left =   (vign_width  - (dct_kernel.img_step * (kernelNumHor-1)))/(2* vign_decimation); // in decimated pixels
-		  final int vgn_top =    (vign_height  -(dct_kernel.img_step * (kernelNumVert-1)))/(2* vign_decimation); // in decimated pixels
-		  final double vgn_max = dct_parameters.vignetting_max;
-		  final double vgn_min = vgn_max/dct_parameters.vignetting_range;
-*/		  
-		  final int chn_green = 2; // all others multiply by 4 as there 1 in 4 Bayer for those, green - by 2
+//		  final int chn_green = 2; // all others multiply by 4 as there 1 in 4 Bayer for those, green - by 2
 		  final long startTime = System.nanoTime();
 		  System.out.println("calculateDCTKernel():numberOfKernels="+numberOfKernels);
 		  for (int ithread = 0; ithread < threads.length; ithread++) {
@@ -239,15 +229,11 @@ public class EyesisDCT {
 					  if (dct_parameters.decimateSigma > 0)	 gb=new DoubleGaussianBlur();
 					  float [] kernelPixels= null; // will be initialized at first use NOT yet?
 					  double [] kernel=      new double[kernelSize*kernelSize];
-					  
-//					  int targetSize = dct_parameters.asym_size + 2 * dct_parameters.dct_size - 2;
-					  
 					  double [] pre_target_kernel= new double [preTargetSize * preTargetSize]; // before made antiperiodic 
 					  double [] target_kernel = new double [targetSize * targetSize]; // strictly antiperiodic in both x and y directions
 					  
 					  FactorConvKernel factorConvKernel = new FactorConvKernel();
 					  factorConvKernel.setDebugLevel       (0); // globalDebugLevel);
-//					  factorConvKernel.setTargetWindowMode (dct_parameters.dbg_window_mode, dct_parameters.centerWindowToTarget);
 					  factorConvKernel.setTargetWindowMode (dct_parameters.centerWindowToTarget);
 					  factorConvKernel.numIterations =     dct_parameters.LMA_steps;
 					  factorConvKernel.setAsymCompactness  (dct_parameters.compactness,	dct_parameters.asym_tax_free);
@@ -255,27 +241,10 @@ public class EyesisDCT {
 					  factorConvKernel.setDCWeight         (dct_parameters.dc_weight);
 					  
 					  int chn,tileY,tileX;
-//					  int chn0=-1;
-//					  int i;
-//					  double sum;
 					  for (int nTile = ai.getAndIncrement(); nTile < numberOfKernels; nTile = ai.getAndIncrement()) {
 						  chn=nTile/numberOfKernelsInChn;
 						  tileY =(nTile % numberOfKernelsInChn)/kernelNumHor;
 						  tileX = nTile % kernelNumHor;
-/*						  
-						  if (vignetting != null){
-							  int vh = vgn_left + vgn_step * tileX;
-							  if (vh < 0)           vh = 0;
-							  if (vh >= vgn_width)  vh = vgn_width -1;
-							  int vv = vgn_top + vgn_step * tileY;
-							  if (vv < 0)           vv = 0;
-							  if (vv >= vgn_height) vh = vgn_height -1;
-							  kscale = vignetting[chn][vv*vgn_width+vh];
-							  if (kscale < vgn_min) kscale = vgn_min; 
-						  }
-						  kscale = vgn_max/kscale * ((chn == chn_green)? 2:4);
-*/						  
-////						  kscale = (chn == chn_green)? 2:4;
 						  if (tileX==0) {
 							  if (updateStatus) IJ.showStatus("Processing kernels, channel "+(chn+1)+" of "+nChn+", row "+(tileY+1)+" of "+kernelNumVert);
 							  if (globalDebugLevel>2) System.out.println("Processing kernels, channel "+(chn+1)+" of "+nChn+", row "+(tileY+1)+" of "+kernelNumVert+" : "+IJ.d2s(0.000000001*(System.nanoTime()-startTime),3));
@@ -339,22 +308,13 @@ public class EyesisDCT {
 						  double [] asym_kernel = factorConvKernel.getAsymKernel();
 						  int sym_kernel_inc_index =   kernelNumHor * dct_parameters.dct_size;
 						  int sym_kernel_start_index = (sym_kernel_inc_index * tileY + tileX) * dct_parameters.dct_size;
-//						  int indx = 0;
 						  for (int i = 0; i<dct_parameters.dct_size;i++){
-							  
 								System.arraycopy(
 										sym_kernel,
 										i * dct_parameters.dct_size,
 										dct_kernel.sym_kernels[chn],
 										sym_kernel_start_index + i * sym_kernel_inc_index,
 										dct_parameters.dct_size);
-
-							  /*
-							  int dst_start = sym_kernel_start_index + i * sym_kernel_inc_index;
-							  for (int j = 0; j < dct_parameters.dct_size; j++){
-								  dct_kernel.sym_kernels[chn][dst_start++] = sym_kernel[indx++];
-							  }
-							  */
 						  }
 						  int asym_kernel_inc_index =   kernelNumHor * dct_parameters.asym_size;
 						  int asym_kernel_start_index = (asym_kernel_inc_index * tileY + tileX)* dct_parameters.asym_size;
@@ -374,7 +334,6 @@ public class EyesisDCT {
 		  if (globalDebugLevel > 1) System.out.println("Threads done at "+IJ.d2s(0.000000001*(System.nanoTime()-startTime),3));
 		  System.out.println("1.Threads done at "+IJ.d2s(0.000000001*(System.nanoTime()-startTime),3));
 		  /* prepare result stack to return */
-//		  ImageStack outStack=new ImageStack(kernelNumHor,kernelNumVert);
 		  return dct_kernel;
 	  }
 //processChannelImage	
@@ -408,8 +367,6 @@ public class EyesisDCT {
 	  
 		  final int kernelWidth=kernelStack.getWidth();
 		  final int kernelNumHor=kernelWidth/kernelSize;
-//		  final int kernelNumVert=kernelStack.getHeight()/kernelSize;
-//		  final int nChn=kernelStack.getSize();
 		  double [] kernel = new double [kernelSize*kernelSize];
 		  extractOneKernel((float[]) kernelStack.getPixels(chn+1), //  array of combined square kernels, each 
 				  kernel,        // will be filled, should have correct size before call
@@ -418,8 +375,6 @@ public class EyesisDCT {
 				  yTile);
 		  return kernel;
 	  }
-	  
-	  //imp2.getStack()
 	  // to be used in threaded method
 	  private void extractOneKernel(float [] pixels, //  array of combined square kernels, each 
 			  double [] kernel, // will be filled, should have correct size before call
@@ -440,6 +395,7 @@ public class EyesisDCT {
 		  int base=(yTile*pixelsWidth+xTile)*size;
 		  for (i=0;i<size;i++) for (j=0;j<size;j++) kernel [i*size+j]=pixels[base+i*pixelsWidth+j];
 	  }
+
 	  public double [] reformatKernel(
 			  double [] src_kernel,// will be blured in-place
 			  int       src_size,  // typical 64
@@ -602,6 +558,10 @@ public class EyesisDCT {
 			  }
 		  }
 	  }
+	  public void resetDCTKernels()
+	  {
+		  kernels = null;
+	  }
 
 	  public boolean readDCTKernels(
 			  EyesisCorrectionParameters.DCTParameters dct_parameters,
@@ -611,7 +571,7 @@ public class EyesisDCT {
 			  int          debugLevel
 			  ){
 		  String [] symKernelPaths = correctionsParameters.selectDCTChannelFiles(
-//					0,  // 0 - sharp, 1 - smooth
+				  //					0,  // 0 - sharp, 1 - smooth
 				  eyesisCorrections.usedChannels.length, // numChannels, // number of channels
 				  eyesisCorrections.debugLevel);
 		  if (symKernelPaths==null) return false;
@@ -637,7 +597,7 @@ public class EyesisDCT {
 		  DttRad2 dtt = new DttRad2(dct_parameters.dct_size);
 
 		  for (int chn=0;chn<eyesisCorrections.usedChannels.length;chn++){
-//				if (eyesisCorrections.usedChannels[chn] && (symKernelPaths[chn]!=null) && (kernels[chn]==null)){
+			  //				if (eyesisCorrections.usedChannels[chn] && (symKernelPaths[chn]!=null) && (kernels[chn]==null)){
 			  if (eyesisCorrections.usedChannels[chn] && (symKernelPaths[chn]!=null)){
 				  ImagePlus imp_kernel_sym=new ImagePlus(symKernelPaths[chn]);
 				  if (imp_kernel_sym.getStackSize()<3) {
@@ -684,11 +644,9 @@ public class EyesisDCT {
 				  int sym_width =  kernels[chn].numHor * dct_size;
 				  int sym_height = kernels[chn].sym_kernels[0].length /sym_width;
 				  int asym_nonzero =kernels[chn].asym_nonzero;
-//					sdfa_instance.showArrays(kernels[chn].sym_kernels,  sym_width, sym_height, true, symKernelPaths[chn]);
 
 				  int asym_width =  kernels[chn].numHor * kernels[chn].asym_size;
 				  int asym_height = kernels[chn].asym_kernels[0].length /asym_width;
-//					sdfa_instance.showArrays(kernels[chn].asym_kernels,  asym_width, asym_height, true, asymKernelPaths[chn]);
 				  int numHor =   kernels[chn].numHor;
 				  int numVert =  kernels[chn].sym_kernels[0].length / (dct_size * dct_size * numHor);
 				  kernels[chn].st_kernels = new double [nColors][numVert][numHor][dct_size * dct_size];
@@ -758,22 +716,24 @@ public class EyesisDCT {
 										  System.out.println("i="+i+", sum="+scale_asym);
 									  }
 								  }
+							  } else {
+								  scale_asym = 1.0;
+							  }
+							  // Compensate for Bayer pattern where there are twice less R,B than G
 							  double k = ((nc == 2)? 1.0:2.0) / scale_asym;
 							  for (int i = 0; i < kernels[chn].asym_val[nc][tileY][tileX].length;i++){
-//										kernels[chn].asym_val[nc][tileY][tileX][i] /= scale_asym;
+								  //										kernels[chn].asym_val[nc][tileY][tileX][i] /= scale_asym;
 								  kernels[chn].asym_val[nc][tileY][tileX][i] *= k; // includes correction for different number of pixels in r,b(1/4) and G (2/4)
 							  }
-									if ((debugLevel>0) && (tileY==67) && (tileX==125)) {
-										System.out.println("nc="+nc+" sum="+scale_asym+", normalized:");
+							  
+							  if ((debugLevel > 0) && (tileY==67) && (tileX==125)) {
+								  System.out.println("nc="+nc+" sum="+scale_asym+", k="+k +", k*scale_asym="+(k*scale_asym)+", normalized:");
 
 								  for (int i=0; i<kernels[chn].asym_indx[nc][tileY][tileX].length; i++){
 									  System.out.println("kernels["+chn+"].asym_val["+nc+"]["+tileY+"]["+tileX+"]["+i+"]="+kernels[chn].asym_val[nc][tileY][tileX][i]);
 									  System.out.println("kernels["+chn+"].asym_indx["+nc+"]["+tileY+"]["+tileX+"]["+i+"]="+kernels[chn].asym_indx[nc][tileY][tileX][i]);
 								  }
 							  }
-								} else {
-									scale_asym = 1.0;
-								}
 
 							  // extract DCT (symmetrical) kernels
 							  int sym_kernel_start_index = (sym_kernel_inc_index * tileY + tileX) * dct_size;
@@ -829,10 +789,10 @@ public class EyesisDCT {
 								  kernels[chn].st_kernels[nc][tileY][tileX][i] *= dct_size;  
 							  }
 
-//								kernels[chn].st_kernels[nc][tileY][tileX]= dtt.dttt_iii(kernels[chn].st_kernels[nc][tileY][tileX]);
+							  //								kernels[chn].st_kernels[nc][tileY][tileX]= dtt.dttt_iii(kernels[chn].st_kernels[nc][tileY][tileX]);
 							  kernels[chn].st_kernels[nc][tileY][tileX]= dtt.dttt_iiie(kernels[chn].st_kernels[nc][tileY][tileX]);
 						  }
-//							System.out.println("tileY="+tileY);
+						  //							System.out.println("tileY="+tileY);
 					  }
 				  }
 				  // Debug will be removed later, the
@@ -848,10 +808,10 @@ public class EyesisDCT {
 	  }
 		
 	  public void showKernels(){
-//			System.out.println("showKernels(): kernels.length="+kernels.length);
+		  //			System.out.println("showKernels(): kernels.length="+kernels.length);
 		  for (int chn=0;chn < kernels.length; chn++){
 			  if (kernels[chn]!=null){
-//					System.out.println("showKernels("+chn+")");
+				  //					System.out.println("showKernels("+chn+")");
 				  showKernels(chn);
 			  }
 		  }
@@ -865,7 +825,7 @@ public class EyesisDCT {
 		  int asym_size= kernels[chn].asym_size;
 		  int sym_width =  numHor * dct_size;
 		  int sym_height = numVert * dct_size;
-//			int asym_nonzero =kernels[chn].asym_nonzero;
+		  //			int asym_nonzero =kernels[chn].asym_nonzero;
 		  int asym_width =  numHor * kernels[chn].asym_size;
 		  int asym_height = numVert * kernels[chn].asym_size;
 		  kernels[chn].sym_kernels =  new double [nColors][sym_width*sym_height];
@@ -941,13 +901,13 @@ public class EyesisDCT {
 		  kernels[chn].sym_direct = null;  // not needed anymore
 	  }
 
-//		public boolean isChannelEnabled(int channel){
-//			return ((channel>=0) && (channel<this.usedChannels.length) && this.usedChannels[channel]);  
-//		}
+	  //		public boolean isChannelEnabled(int channel){
+	  //			return ((channel>=0) && (channel<this.usedChannels.length) && this.usedChannels[channel]);  
+	  //		}
 
 
 	  public void processDCTChannelImages(
-//				EyesisCorrectionParameters.SplitParameters         splitParameters,
+			  //				EyesisCorrectionParameters.SplitParameters         splitParameters,
 			  EyesisCorrectionParameters.DCTParameters           dct_parameters,
 			  EyesisCorrectionParameters.DebayerParameters     debayerParameters,
 			  EyesisCorrectionParameters.NonlinParameters       nonlinParameters,
@@ -971,6 +931,7 @@ public class EyesisDCT {
 				  int [] channels={correctionsParameters.getChannelFromSourceTiff(sourceFiles[nFile])};
 				  if (correctionsParameters.isJP4()){
 					  int subCamera= channels[0]- correctionsParameters.firstSubCamera; // to match those in the sensor files
+					  // removeUnusedSensorData should be off!?
 					  channels=this.eyesisCorrections.pixelMapping.channelsForSubCamera(subCamera);
 				  }
 				  if (channels!=null){
@@ -1009,7 +970,7 @@ public class EyesisDCT {
 		  for (int iImage=0;iImage<fileIndices.length;iImage++){
 			  int nFile=fileIndices[iImage][0];
 			  ImagePlus imp_src=null;
-//				  int srcChannel=correctionsParameters.getChannelFromSourceTiff(sourceFiles[nFile]);
+			  //				  int srcChannel=correctionsParameters.getChannelFromSourceTiff(sourceFiles[nFile]);
 			  int srcChannel=fileIndices[iImage][1];
 			  if (correctionsParameters.isJP4()){
 				  int subchannel=eyesisCorrections.pixelMapping.getSubChannel(srcChannel);
@@ -1033,23 +994,23 @@ public class EyesisDCT {
 				  // do we need to add any properties?				  
 			  } else { 
 				  imp_src=new ImagePlus(sourceFiles[nFile]);
-//					  (new JP46_Reader_camera(false)).decodeProperiesFromInfo(imp_src); // decode existent properties from info
+				  //					  (new JP46_Reader_camera(false)).decodeProperiesFromInfo(imp_src); // decode existent properties from info
 				  eyesisCorrections.JP4_INSTANCE.decodeProperiesFromInfo(imp_src); // decode existent properties from info
 				  if (debugLevel>0) System.out.println("Processing "+sourceFiles[nFile]);
 			  }
 			  double scaleExposure=1.0;
 			  if (!Double.isNaN(referenceExposures[nFile]) && (imp_src.getProperty("EXPOSURE")!=null)){
 				  scaleExposure=referenceExposures[nFile]/Double.parseDouble((String) imp_src.getProperty("EXPOSURE"));
-//					  imp_src.setProperty("scaleExposure", scaleExposure); // it may already have channel
+				  //					  imp_src.setProperty("scaleExposure", scaleExposure); // it may already have channel
 				  if (debugLevel>0) System.out.println("Will scale intensity (to compensate for exposure) by  "+scaleExposure);
 			  }
 			  imp_src.setProperty("name",    correctionsParameters.getNameFromSourceTiff(sourceFiles[nFile]));
 			  imp_src.setProperty("channel", srcChannel); // it may already have channel
 			  imp_src.setProperty("path",    sourceFiles[nFile]); // it may already have channel
-//				  ImagePlus result=processChannelImage( // returns ImagePlus, but it already should be saved/shown
+			  //				  ImagePlus result=processChannelImage( // returns ImagePlus, but it already should be saved/shown
 			  processDCTChannelImage( // returns ImagePlus, but it already should be saved/shown
 					  imp_src, // should have properties "name"(base for saving results), "channel","path"
-//						  splitParameters,
+					  //						  splitParameters,
 					  dct_parameters,
 					  debayerParameters,
 					  nonlinParameters,
@@ -1080,7 +1041,7 @@ public class EyesisDCT {
 
 	  public ImagePlus processDCTChannelImage(
 			  ImagePlus imp_src, // should have properties "name"(base for saving results), "channel","path"
-//				EyesisCorrectionParameters.SplitParameters         splitParameters, // will not be used !
+			  //				EyesisCorrectionParameters.SplitParameters         splitParameters, // will not be used !
 			  EyesisCorrectionParameters.DCTParameters           dct_parameters,
 			  EyesisCorrectionParameters.DebayerParameters     debayerParameters,
 			  EyesisCorrectionParameters.NonlinParameters       nonlinParameters,
@@ -1139,15 +1100,27 @@ public class EyesisDCT {
 				  if (d > max_vign_corr) d = max_vign_corr;
 				  pixels[i]*=d;
 			  }
+			  // Scale here, combine with vignetting later?
+			  int width =  imp_src.getWidth();
+			  int height = imp_src.getHeight();
+			  for (int y = 0; y < height-1; y+=2){
+				  for (int x = 0; x < width-1; x+=2){
+					  pixels[y*width+x        ] *= dct_parameters.scale_g;
+					  pixels[y*width+x+width+1] *= dct_parameters.scale_g;
+					  pixels[y*width+x      +1] *= dct_parameters.scale_r;
+					  pixels[y*width+x+width  ] *= dct_parameters.scale_b;
+				  }
+			  }
+			  
 		  } else { // assuming GR/BG pattern
 			  System.out.println("Applying fixed color gain correction parameters: Gr="+
 					  dct_parameters.novignetting_r+", Gg="+dct_parameters.novignetting_g+", Gb="+dct_parameters.novignetting_b);
 			  float [] pixels=(float []) imp_src.getProcessor().getPixels();
 			  int width =  imp_src.getWidth();
 			  int height = imp_src.getHeight();
-				double kr = 1.0/dct_parameters.novignetting_r;
-				double kg = 1.0/dct_parameters.novignetting_g;
-				double kb = 1.0/dct_parameters.novignetting_b;
+			  double kr = dct_parameters.scale_r/dct_parameters.novignetting_r;
+			  double kg = dct_parameters.scale_g/dct_parameters.novignetting_g;
+			  double kb = dct_parameters.scale_b/dct_parameters.novignetting_b;
 			  for (int y = 0; y < height-1; y+=2){
 				  for (int x = 0; x < width-1; x+=2){
 					  pixels[y*width+x        ] *= kg;
@@ -1179,27 +1152,54 @@ public class EyesisDCT {
 				  result, // source Bayer image, linearized, 32-bit (float))
 				  splitParameters);
 		  String titleFull=title+"-SPLIT";
+		  if (debugLevel > -1){
+			  double [] chn_avg = {0.0,0.0,0.0};
+			  float [] pixels;
+			  int width =  stack.getWidth();
+			  int height = stack.getHeight();
+			  
+			  for (int c = 0; c <3; c++){
+				  pixels = (float[]) stack.getPixels(c+1);
+				  for (int i = 0; i<pixels.length; i++){
+					  chn_avg[c] += pixels[i];
+				  }
+			  }
+			  chn_avg[0] /= width*height/4;
+			  chn_avg[1] /= width*height/4;
+			  chn_avg[2] /= width*height/2;
+			  System.out.println("Split channels averages: R="+chn_avg[0]+", G="+chn_avg[2]+", B="+chn_avg[1]); 
+		  }
+		  
 		  if (!this.correctionsParameters.debayer) {
 			  result= new ImagePlus(titleFull, stack);    			  
 			  eyesisCorrections.saveAndShow(result, this.correctionsParameters);
 			  return result;
 		  }
-// =================
+		  // =================
 		  showDoubleFloatArrays sdfa_instance = new showDoubleFloatArrays(); // just for debugging?
+		  if (debugLevel > 0) {
+			  System.out.println("Showing image BEFORE_PROC");
+			  ImagePlus imp_dbg= new ImagePlus("BEFORE_PROC",stack);
+		      imp_dbg.getProcessor().resetMinAndMax();
+			  imp_dbg.updateAndDraw();
+		      imp_dbg.show();
+		  }
+
 		  if (this.correctionsParameters.deconvolve) { // process with DCT, otherwise use simple debayer
 			  ImageDtt image_dtt = new ImageDtt();
-				double [][][][] dctdc_data = image_dtt.mdctDcStack(
+			  double [][][][] dct_data = image_dtt.mdctStack(
 					  stack,
+					  channel,
 					  dct_parameters,
 					  this,
 					  threadsMax,
 					  debugLevel,
 					  updateStatus);
-				System.out.println("dctdc_data.length="+dctdc_data.length+" dctdc_data[0].length="+dctdc_data[0].length
-						+" dctdc_data[0][0].length="+dctdc_data[0][0].length+" dctdc_data[0][0][0].length="+dctdc_data[0][0][0].length);
+			  System.out.println("dct_data.length="+dct_data.length+" dct_data[0].length="+dct_data[0].length
+					  +" dct_data[0][0].length="+dct_data[0][0].length+" dct_data[0][0][0].length="+dct_data[0][0][0].length);
 			  if (dct_parameters.color_DCT){ // convert RBG -> YPrPb
-					dctdc_data = image_dtt.dct_color_convert(
-							dctdc_data,
+				  dct_data = image_dtt.dct_color_convert(
+						  dct_data,
 						  colorProcParameters.kr,
 						  colorProcParameters.kb,
 						  dct_parameters.sigma_rb,        // blur of channels 0,1 (r,b) in addition to 2 (g)
@@ -1208,71 +1208,53 @@ public class EyesisDCT {
 						  threadsMax,
 						  debugLevel);
 			  } else { // just LPF RGB
-					for (int chn = 0; chn < dctdc_data.length; chn++) {
+				  for (int chn = 0; chn < dct_data.length; chn++) {
 					  image_dtt.dct_lpf(
 							  dct_parameters.dbg_sigma,
-								dctdc_data[chn],
+							  dct_data[chn],
 							  threadsMax,
 							  debugLevel);
 				  }
 
-					//TODO: Scale up 2x to match color processed (or scale up lpf?)
-					
 			  }
 
 			  int tilesY = stack.getHeight()/dct_parameters.dct_size - 1;
 			  int tilesX = stack.getWidth()/dct_parameters.dct_size - 1;
-				if (debugLevel>0){
+			  if (debugLevel > 0){
 				  System.out.println("--tilesX="+tilesX);
 				  System.out.println("--tilesY="+tilesY);
 			  }
-				double [][] dct_dc = new double [dctdc_data.length][];
-				double [][] dct_ac = new double [dctdc_data.length][];
-				for (int chn = 0; chn < dct_dc.length; chn++) {
-					if (!dct_parameters.color_DCT){ // convert RBG -> YPrPb
-						dct_dc[chn] = image_dtt.lapped_dct_dcac(
-								false, //       out_ac, // false - output DC, true - output AC
-								dctdc_data [chn],
-								threadsMax,
-								debugLevel);
-					}
-					dct_ac[chn] = image_dtt.lapped_dct_dcac(
-							true, //       out_ac, // false - output DC, true - output AC
-							dctdc_data [chn],
+			  if (debugLevel > 1){
+				  double [][] dct = new double [dct_data.length][];
+				  for (int chn = 0; chn < dct.length; chn++) {
+					  dct[chn] = image_dtt.lapped_dct_dbg(
+							  dct_data [chn],
 							  threadsMax,
 							  debugLevel);
 				  }
 				  //	        System.out.println("dct_dc.length="+dct_dc.length+" dct_ac.length="+dct_ac.length);
-				if (debugLevel > 0){
-					sdfa_instance.showArrays(dct_ac,
+				  sdfa_instance.showArrays(dct,
 						  tilesX*dct_parameters.dct_size,
 						  tilesY*dct_parameters.dct_size,
 						  true,
-							result.getTitle()+"-DCT_AC");
-					if (!dct_parameters.color_DCT){ // convert RBG -> YPrPb
-						sdfa_instance.showArrays(dct_dc,
-								tilesX,
-								tilesY,
-								true,
-								result.getTitle()+"-DCT_DC");
+						  result.getTitle()+"-DCT");
 			  }
-				}
-				double [][] idct_data = new double [dctdc_data.length][];
+			  double [][] idct_data = new double [dct_data.length][];
 			  for (int chn=0; chn<idct_data.length;chn++){
-					idct_data[chn] = image_dtt.lapped_idctdc(
-							dctdc_data[chn],                  // scanline representation of dcd data, organized as dct_size x dct_size tiles  
+				  idct_data[chn] = image_dtt.lapped_idct(
+						  dct_data[chn],                  // scanline representation of dcd data, organized as dct_size x dct_size tiles  
 						  dct_parameters.dct_size,        // final int
 						  dct_parameters.dct_window,      //window_type
 						  threadsMax,
 						  debugLevel);
 			  }
 			  if (dct_parameters.color_DCT){ // convert RBG -> YPrPb
-					sdfa_instance.showArrays(
+				  if (debugLevel > 0) sdfa_instance.showArrays(
 						  idct_data,
 						  (tilesX + 1) * dct_parameters.dct_size,
 						  (tilesY + 1) * dct_parameters.dct_size,
 						  true,
-							result.getTitle()+"-IDCTDC-YPrPb");
+						  result.getTitle()+"-IDCT-YPrPb");
 				  if (dct_parameters.nonlin && ((dct_parameters.nonlin_y != 0.0) || (dct_parameters.nonlin_c != 0.0))) {
 					  System.out.println("Applying edge emphasis, nonlin_y="+dct_parameters.nonlin_y+
 							  ", nonlin_c="+dct_parameters.nonlin_c+", nonlin_corn="+dct_parameters.nonlin_corn);
@@ -1291,7 +1273,7 @@ public class EyesisDCT {
 							  dct_parameters.denoise_c_corn,          // final double      denoise_c_corn,   // =   0.5;  // weight of the 4 corner pixels during denoise y (relative to 4 straight)
 							  threadsMax,                             // final int         threadsMax,       // maximal number of threads to launch                         
 							  debugLevel);                            // final int         globalDebugLevel)
-						sdfa_instance.showArrays(
+					  if (debugLevel > 0) sdfa_instance.showArrays(
 							  idct_data,
 							  (tilesX + 1) * dct_parameters.dct_size,
 							  (tilesY + 1) * dct_parameters.dct_size,
@@ -1306,14 +1288,14 @@ public class EyesisDCT {
 						  (tilesX + 1) * dct_parameters.dct_size);
 
 			  } else {
-					System.out.println("Bypassing nonlinear correction");
+				  if (debugLevel > 0) System.out.println("Bypassing nonlinear correction");
 			  }
 
-				sdfa_instance.showArrays(idct_data,
+			  if (debugLevel > 0) sdfa_instance.showArrays(idct_data,
 					  (tilesX + 1) * dct_parameters.dct_size,
 					  (tilesY + 1) * dct_parameters.dct_size,
 					  true,
-						result.getTitle()+"-IDCTDC-RGB");
+					  result.getTitle()+"-IDCT-RGB");
 
 			  // convert to ImageStack of 3 slices
 			  String [] sliceNames = {"red", "blue", "green"};
@@ -1325,9 +1307,26 @@ public class EyesisDCT {
 
 
 		  } else { // if (this.correctionsParameters.deconvolve) - here use a simple debayer
-				System.out.println("Bypassing DCTR-based aberration correction");
+			  System.out.println("Bypassing DCT-based aberration correction");
 			  debayer_rbg(stack, 0.25); // simple standard 3x3 kernel debayer
 		  }
+		  if (debugLevel > -1){
+			  double [] chn_avg = {0.0,0.0,0.0};
+			  float [] pixels;
+			  int width =  stack.getWidth();
+			  int height = stack.getHeight();
+			  
+			  for (int c = 0; c <3; c++){
+				  pixels = (float[]) stack.getPixels(c+1);
+				  for (int i = 0; i<pixels.length; i++){
+					  chn_avg[c] += pixels[i];
+				  }
+			  }
+			  chn_avg[0] /= width*height;
+			  chn_avg[1] /= width*height;
+			  chn_avg[2] /= width*height;
+			  System.out.println("Processed channels averages: R="+chn_avg[0]+", G="+chn_avg[2]+", B="+chn_avg[1]); 
+		  }
 		  
 		  if (!this.correctionsParameters.colorProc){
 			  result= new ImagePlus(titleFull, stack);    			  
@@ -1336,7 +1335,7 @@ public class EyesisDCT {
 					  this.correctionsParameters);
 			  return result;
 		  }
-			System.out.println("before colors.1");
+		  if (debugLevel > 1) System.out.println("before colors.1");
 		  //Processing colors - changing stack sequence to r-g-b (was r-b-g)
 		  if (!eyesisCorrections.fixSliceSequence(
 				  stack,
@@ -1344,14 +1343,14 @@ public class EyesisDCT {
 			  if (debugLevel > -1) System.out.println("fixSliceSequence() returned false");
 			  return null;
 		  }
-			System.out.println("before colors.2");
-			if (debugLevel > -1){
+		  if (debugLevel > 1) System.out.println("before colors.2");
+		  if (debugLevel > 1){
 			  ImagePlus imp_dbg=new ImagePlus(imp_src.getTitle()+"-"+channel+"-preColors",stack);
 			  eyesisCorrections.saveAndShow(
 					  imp_dbg,
 					  this.correctionsParameters);
 		  }
-			System.out.println("before colors.3, scaleExposure="+scaleExposure+" scale = "+(255.0/eyesisCorrections.psfSubpixelShouldBe4/eyesisCorrections.psfSubpixelShouldBe4/scaleExposure));
+		  if (debugLevel > 1) System.out.println("before colors.3, scaleExposure="+scaleExposure+" scale = "+(255.0/eyesisCorrections.psfSubpixelShouldBe4/eyesisCorrections.psfSubpixelShouldBe4/scaleExposure));
 		  CorrectionColorProc correctionColorProc=new CorrectionColorProc(eyesisCorrections.stopRequested);
 		  double [][] yPrPb=new double [3][];
 		  //			if (dct_parameters.color_DCT){
@@ -1368,8 +1367,8 @@ public class EyesisDCT {
 				  null, //correctionDenoise.getDenoiseMask(),
 				  this.correctionsParameters.blueProc,
 				  debugLevel);
-			if (debugLevel > -1) System.out.println("Processed colors to YPbPr, total number of slices="+stack.getSize());
-			if (debugLevel > 0){
+		  if (debugLevel > 1) System.out.println("Processed colors to YPbPr, total number of slices="+stack.getSize());
+		  if (debugLevel > 1) {
 			  ImagePlus imp_dbg=new ImagePlus("procColors",stack);
 			  eyesisCorrections.saveAndShow(
 					  imp_dbg,
@@ -1383,17 +1382,6 @@ public class EyesisDCT {
 			  yPrPb[n] = new double [fpixels.length];
 			  for (int i = 0; i < fpixels.length; i++) yPrPb[n][i] = fpixels[i];
 		  }
-			//			}
-			/*
-			String [] slice_names_YPrPb={"Y","Pr","Pb"};
-			sdfa_instance.showArrays(idct_data,
-					stack.getWidth(), // (tilesX + 1) * dct_parameters.dct_size,
-					stack.getHeight(), // (tilesY + 1) * dct_parameters.dct_size,
-					true,
-					result.getTitle()+"-YPrPb",
-					slice_names_YPrPb);
-			*/		
-
 
 		  if (toRGB) {
 			  System.out.println("correctionColorProc.YPrPbToRGB");
@@ -1402,40 +1390,29 @@ public class EyesisDCT {
 					  colorProcParameters.kb,        // 0.114;
 					  stack.getWidth());
 
-				/*
-				correctionColorProc.YPrPbToRGB(stack,
-						colorProcParameters.kr,        // 0.299;
-						colorProcParameters.kb,        // 0.114;
-						colorProcParameters.useFirstY?9:8,        //  int sliceY,
-								6, // int slicePr,
-								7// int slicePb
-						);
-
-				 */
-
 			  title=titleFull; // including "-DECONV" or "-COMBO"
 			  titleFull=title+"-RGB-float";
 			  //Trim stack to just first 3 slices
-				if (debugLevel > 0){ // 2){
+			  if (debugLevel > 1){ // 2){
 				  ImagePlus imp_dbg=new ImagePlus("YPrPbToRGB",stack);
 				  eyesisCorrections.saveAndShow(
 						  imp_dbg,
 						  this.correctionsParameters);
 			  }
 			  while (stack.getSize() > 3) stack.deleteLastSlice();
-				if (debugLevel > -1) System.out.println("Trimming color stack");
+			  if (debugLevel > 1) System.out.println("Trimming color stack");
 		  } else {
 			  title=titleFull; // including "-DECONV" or "-COMBO"
 			  titleFull=title+"-YPrPb"; // including "-DECONV" or "-COMBO"
-				if (debugLevel > -1) System.out.println("Using full stack, including YPbPr");
+			  if (debugLevel > 1) System.out.println("Using full stack, including YPbPr");
 		  }
 
 		  result= new ImagePlus(titleFull, stack);    			  
 		  // Crop image to match original one (scaled to oversampling)
 		  if (crop){ // always crop if equirectangular
-				System.out.println("cropping");
+			  if (debugLevel > 1) System.out.println("cropping");
 			  stack = eyesisCorrections.cropStack32(stack,splitParameters);
-				if (debugLevel > -1) { // 2){
+			  if (debugLevel > 2) { // 2){
 				  ImagePlus imp_dbg=new ImagePlus("cropped",stack);
 				  eyesisCorrections.saveAndShow(
 						  imp_dbg,
@@ -1447,11 +1424,11 @@ public class EyesisDCT {
 			  stack=eyesisCorrections.rotateStack32CW(stack);
 		  }
 		  if (!toRGB && !this.correctionsParameters.jpeg){ // toRGB set for equirectangular
-				System.out.println("!toRGB && !this.correctionsParameters.jpeg");
+			  if (debugLevel > 1) System.out.println("!toRGB && !this.correctionsParameters.jpeg");
 			  eyesisCorrections.saveAndShow(result, this.correctionsParameters);
 			  return result;
 		  } else { // that's not the end result, save if required
-				System.out.println("!toRGB && !this.correctionsParameters.jpeg - else");
+			  if (debugLevel > 1) System.out.println("!toRGB && !this.correctionsParameters.jpeg - else");
 			  eyesisCorrections.saveAndShow(result,
 					  eyesisCorrections.correctionsParameters,
 					  eyesisCorrections.correctionsParameters.save32,
@@ -1468,16 +1445,16 @@ public class EyesisDCT {
 		  result= new ImagePlus(titleFull, stack);
 		  //			  ImagePlus imp_RGB24;
 		  result.updateAndDraw();
-			System.out.println("result.updateAndDraw(), "+titleFull+"-RGB48");
+		  if (debugLevel > 1) System.out.println("result.updateAndDraw(), "+titleFull+"-RGB48");
 
 		  CompositeImage compositeImage=eyesisCorrections.convertToComposite(result);
 
 		  if (!this.correctionsParameters.jpeg && !advanced){ // RGB48 was the end result
-				System.out.println("if (!this.correctionsParameters.jpeg && !advanced)");
+			  if (debugLevel > 1) System.out.println("if (!this.correctionsParameters.jpeg && !advanced)");
 			  eyesisCorrections.saveAndShow(compositeImage, this.correctionsParameters);
 			  return result;
 		  } else { // that's not the end result, save if required
-				System.out.println("if (!this.correctionsParameters.jpeg && !advanced) - else");
+			  if (debugLevel > 1) System.out.println("if (!this.correctionsParameters.jpeg && !advanced) - else");
 			  eyesisCorrections.saveAndShow(compositeImage, this.correctionsParameters, this.correctionsParameters.save16, false); // save, no show
 			  //				  eyesisCorrections.saveAndShow(compositeImage, this.correctionsParameters, this.correctionsParameters.save16, true); // save, no show
 		  }
@@ -1546,7 +1523,7 @@ public class EyesisDCT {
 			  int width
 			  ) {
 		  int length = yPrPb[0].length;
-//			int height = length/width;
+		  //			int height = length/width;
 
 		  double [][]rbg = new double[3][length];
 		  double Kg=1.0-Kr-Kb;

src/main/java/Eyesis_Correction.java

@@ -454,7 +454,6 @@ private Panel panel1,panel2,panel3,panel4,panel5,panel5a, panel6,panel7,panelPos
 			addButton("DCT test 1",                panelDct1, color_process);
 			addButton("select MDCT image",         panelDct1, color_configure);
 			addButton("MDCT stack",                panelDct1, color_process);
-			addButton("MDCT DC stack",             panelDct1, color_process);
 			addButton("DCT test 3",                panelDct1, color_process);
 			addButton("DCT test 4",                panelDct1, color_process);
 			addButton("Test Kernel Factorization", panelDct1, color_process);
@@ -462,6 +461,7 @@ private Panel panel1,panel2,panel3,panel4,panel5,panel5a, panel6,panel7,panelPos
 			addButton("Select kernels image",      panelDct1, color_configure);
 			addButton("Create DCT kernels",        panelDct1, color_process);
 			addButton("Read DCT kernels",          panelDct1, color_process);
+			addButton("Reset DCT kernels",         panelDct1, color_stop);
 			addButton("Setup DCT parameters",      panelDct1, color_configure);
 			addButton("DCT process files",         panelDct1, color_process);
 			add(panelDct1);
@@ -2627,70 +2627,8 @@ private Panel panel1,panel2,panel3,panel4,panel5,panel5a, panel6,panel7,panelPos
            	DBG_IMP = imp_src;
            }
  /* ======================================================================== */
-    } else if (label.equals("MDCT stack")) {
-    	DEBUG_LEVEL=MASTER_DEBUG_LEVEL;
-//    	IJ.showMessage("DCT test 1");
-        if (!DCT_PARAMETERS.showDialog()) return;
-// process selected image stack
-        if (DBG_IMP == null) {
-        	ImagePlus imp_src = WindowManager.getCurrentImage();
-        	if (imp_src==null){
-        		IJ.showMessage("Error","JP4 image or Bayer image stack required");
-        		return;
-        	}
-//        	ImagePlus imp2;
-        	if (imp_src.getStackSize()<3){ // convert JP4 to image stack
-
-        		EyesisCorrectionParameters.SplitParameters split_parameters = new EyesisCorrectionParameters.SplitParameters(
-        				1,  // oversample;
-        				// Add just for mdct (N/2)
-        				DCT_PARAMETERS.dct_size/2, // addLeft
-        				DCT_PARAMETERS.dct_size/2, // addTop
-        				DCT_PARAMETERS.dct_size/2, // addRight
-        				DCT_PARAMETERS.dct_size/2  // addBottom
-        				);		   
-
-
-        		ImageStack sourceStack= bayerToStack(imp_src, // source Bayer image, linearized, 32-bit (float))
-        				split_parameters);
-        		DBG_IMP = new ImagePlus(imp_src.getTitle()+"-SPIT", sourceStack);
-        		DBG_IMP.getProcessor().resetMinAndMax();
-        		DBG_IMP.show();
-        	} else {
-        		DBG_IMP = imp_src;
-        	}
-        }
-        ImageDtt image_dtt = new ImageDtt();
-        double [][] dct_data = image_dtt.mdctStack(DBG_IMP.getStack(),
-        		                                   DCT_PARAMETERS,
-        		                                   THREADS_MAX, DEBUG_LEVEL, UPDATE_STATUS);
-        int tilesY = DBG_IMP.getHeight()/DCT_PARAMETERS.dct_size - 1;
-        int tilesX = DBG_IMP.getWidth()/DCT_PARAMETERS.dct_size - 1;
-        System.out.println("tilesX="+tilesX);
-        System.out.println("tilesY="+tilesY);
-        SDFA_INSTANCE.showArrays(dct_data,
-        		tilesX*DCT_PARAMETERS.dct_size,
-        		tilesY*DCT_PARAMETERS.dct_size,
-        		true,
-        		DBG_IMP.getTitle()+"-DCT");  
-        double [][] idct_data = new double [dct_data.length][];
-        for (int chn=0; chn<idct_data.length;chn++){
-        	idct_data[chn] = image_dtt.lapped_idct(
-        			dct_data[chn],                  // scanline representation of dcd data, organized as dct_size x dct_size tiles  
-        			tilesX*DCT_PARAMETERS.dct_size, //   dct_width,
-        			DCT_PARAMETERS.dct_size,        // final int
-        			DCT_PARAMETERS.dct_window,      //window_type
-        			THREADS_MAX,                    // maximal number of threads to launch                         
-        			DEBUG_LEVEL);                   //        globalDebugLevel)
-        }
-        SDFA_INSTANCE.showArrays(idct_data,
-        		(tilesX + 1) * DCT_PARAMETERS.dct_size,
-        		(tilesY + 1) * DCT_PARAMETERS.dct_size,
-        		true,
-        		DBG_IMP.getTitle()+"-IDCT");  
-    	return;
 /* ======================================================================== */
-    } else if (label.equals("MDCT DC stack")) {
+    } else if (label.equals("MDCT stack")) {
     	DEBUG_LEVEL=MASTER_DEBUG_LEVEL;
 //    	IJ.showMessage("DCT test 1");
         if (!DCT_PARAMETERS.showDialog()) return;
@@ -2725,8 +2663,9 @@ private Panel panel1,panel2,panel3,panel4,panel5,panel5a, panel6,panel7,panelPos
 
         }
         ImageDtt image_dtt = new ImageDtt();
-        double [][][][] dctdc_data = image_dtt.mdctDcStack(
+        double [][][][] dctdc_data = image_dtt.mdctStack(
         		DBG_IMP.getStack(),
+        		DCT_PARAMETERS.kernel_chn,
         		DCT_PARAMETERS,
         		EYESIS_DCT,
         		THREADS_MAX, DEBUG_LEVEL, UPDATE_STATUS);
@@ -2743,36 +2682,24 @@ private Panel panel1,panel2,panel3,panel4,panel5,panel5a, panel6,panel7,panelPos
         int tilesX = DBG_IMP.getWidth()/DCT_PARAMETERS.dct_size - 1;
         System.out.println("tilesX="+tilesX);
         System.out.println("tilesY="+tilesY);
-        double [][] dct_dc = new double [dctdc_data.length][];
-        double [][] dct_ac = new double [dctdc_data.length][];
-        for (int chn = 0; chn < dct_dc.length; chn++) {
-        	dct_dc[chn] = image_dtt.lapped_dct_dcac(
-        			false, //       out_ac, // false - output DC, true - output AC
-        			dctdc_data [chn],
-        			THREADS_MAX,
-        			DEBUG_LEVEL);
-        	dct_ac[chn] = image_dtt.lapped_dct_dcac(
-        			true, //       out_ac, // false - output DC, true - output AC
+        double [][] dct = new double [dctdc_data.length][];
+        for (int chn = 0; chn < dct.length; chn++) {
+        	dct[chn] = image_dtt.lapped_dct_dbg(
         			dctdc_data [chn],
         			THREADS_MAX,
         			DEBUG_LEVEL);
         }
 //        System.out.println("dct_dc.length="+dct_dc.length+" dct_ac.length="+dct_ac.length);
         if (DEBUG_LEVEL > 0){
-        	SDFA_INSTANCE.showArrays(dct_ac,
+        	SDFA_INSTANCE.showArrays(dct,
         			tilesX*DCT_PARAMETERS.dct_size,
         			tilesY*DCT_PARAMETERS.dct_size,
         			true,
-        			DBG_IMP.getTitle()+"-DCT_AC");  
-        	SDFA_INSTANCE.showArrays(dct_dc,
-        			tilesX,
-        			tilesY,
-        			true,
-        			DBG_IMP.getTitle()+"-DCT_DC");
+        			DBG_IMP.getTitle()+"-DCT");  
         }
         double [][] idct_data = new double [dctdc_data.length][];
         for (int chn=0; chn<idct_data.length;chn++){
-        	idct_data[chn] = image_dtt.lapped_idctdc(
+        	idct_data[chn] = image_dtt.lapped_idct(
         			dctdc_data[chn],                  // scanline representation of dcd data, organized as dct_size x dct_size tiles  
         			DCT_PARAMETERS.dct_size,        // final int
         			DCT_PARAMETERS.dct_window,      //window_type
@@ -3503,14 +3430,15 @@ private Panel panel1,panel2,panel3,panel4,panel5,panel5a, panel6,panel7,panelPos
         
         EYESIS_DCT.createDCTKernels(
         		DCT_PARAMETERS,
-/*        		
-        		EYESIS_CORRECTIONS.pixelMapping,
-*/        		
         		CONVOLVE_FFT_SIZE/2,
                 THREADS_MAX,
                 UPDATE_STATUS, // update status info
         		DEBUG_LEVEL);
-
+//"Reset DCT kernels"
+    } else if (label.equals("Reset DCT kernels")) {
+        if (EYESIS_DCT != null){
+        	EYESIS_DCT.resetDCTKernels();
+        }
     } else if (label.equals("Read DCT kernels")) {
         if (!DCT_PARAMETERS.showDialog()) return;
         if (EYESIS_DCT == null){

src/main/java/ImageDtt.java

@@ -31,175 +31,9 @@ public class ImageDtt {
 
 	}
 
-	public double [][] mdctStack(
-			final ImageStack                                 imageStack,
-			final EyesisCorrectionParameters.DCTParameters   dctParameters, //
-			final int                                        threadsMax, // maximal step in pixels on the maxRadius for 1 angular step (i.e. 0.5)
-			final int                                        debugLevel,
-			final boolean                                    updateStatus) // update status info
-
-	{
-	  	  if (imageStack==null) return null;
-		  final int imgWidth=imageStack.getWidth();
-		  final int nChn=imageStack.getSize();
-		  double [][] dct_data = new double [nChn][];
-		  float [] fpixels;
-		  int i,chn; //tileX,tileY;
-		  /* find number of the green channel - should be called "green", if none - use last */
-		  // Extract float pixels from inage stack, convert each to double
-
-		  for (chn=0;chn<nChn;chn++) {
-			  fpixels= (float[]) imageStack.getPixels(chn+1);
-			  double[] dpixels = new double[fpixels.length];
-			  for (i = 0; i <fpixels.length;i++) dpixels[i] = fpixels[i];
-			  // convert each to DCT tiles
-			  dct_data[chn] =lapped_dct(
-						dpixels,
-						imgWidth,
-						dctParameters.dct_size,
-						0, //     dct_mode,    // 0: dct/dct, 1: dct/dst, 2: dst/dct, 3: dst/dst
-						dctParameters.dct_window, // final int       window_type,
-						threadsMax,  // maximal number of threads to launch                         
-						debugLevel);
-		  }
-		return dct_data;
-	}
-
-	public double [] lapped_dct(
-			final double [] dpixels,
-			final int       width,
-			final int       dct_size,
-			final int       dct_mode,    // 0: dct/dct, 1: dct/dst, 2: dst/dct, 3: dst/dst
-			final int       window_type,
-			final int       threadsMax,  // maximal number of threads to launch                         
-			final int       globalDebugLevel)
-	{
-		final int height=dpixels.length/width;
-		final int tilesX=width/dct_size-1;
-		final int tilesY=height/dct_size-1;
-		final int nTiles=tilesX*tilesY; 
-		final double [] dct_data = new double[tilesY*tilesX*dct_size*dct_size];
-		final Thread[] threads = newThreadArray(threadsMax);
-		final AtomicInteger ai = new AtomicInteger(0);
-		for (int i=0; i<dct_data.length;i++) dct_data[i]= 0;
-
-		for (int ithread = 0; ithread < threads.length; ithread++) {
-			threads[ithread] = new Thread() {
-				public void run() {
-					DttRad2 dtt = new DttRad2(dct_size);
-					dtt.set_window(window_type);
-					double [] tile_in = new double[4*dct_size * dct_size];
-					double [] tile_folded;
-					double [] tile_out; // = new double[dct_size * dct_size];
-					int tileY,tileX;
-					int n2 = dct_size * 2;
-					for (int nTile = ai.getAndIncrement(); nTile < nTiles; nTile = ai.getAndIncrement()) {
-						tileY = nTile/tilesX;
-						tileX = nTile - tileY * tilesX;
-						for (int i = 0; i < n2;i++){
-							System.arraycopy(dpixels, (tileY*width+tileX)*dct_size + i*width, tile_in, i*n2, n2);
-						}
-//						tile_out=dtt.mdct_2d(tile_in, dct_mode, dct_size);
-						tile_folded=dtt.fold_tile(tile_in, dct_size);
-						tile_out=dtt.dttt_iv  (tile_folded, dct_mode, dct_size);
-						for (int i = 0; i < dct_size;i++){
-							System.arraycopy(tile_out, dct_size* i, dct_data, ((tileY*dct_size + i) *tilesX + tileX)*dct_size , dct_size);
-						}
-					}
-				}
-			};
-		}		      
-		startAndJoin(threads);
-		return dct_data;
-	}
-	
-	
-	
-	
-	
-	public double [] lapped_idct(
-			final double [] dct_data,  // scanline representation of dcd data, organized as dct_size x dct_size tiles  
-			final int       dct_width,
-			final int       dct_size,
-			final int       window_type,
-			final int       threadsMax,  // maximal number of threads to launch                         
-			final int       globalDebugLevel)
-	{
-		final int tilesX=dct_width/dct_size;
-		final int tilesY=dct_data.length/(dct_width*dct_size);
-		final int width=  (tilesX+1)*dct_size;
-		final int height= (tilesY+1)*dct_size;
-		if (globalDebugLevel > 0) {
-			System.out.println("lapped_idct():dct_width="+dct_width);
-			System.out.println("lapped_idct():tilesX=   "+tilesX);
-			System.out.println("lapped_idct():tilesY=   "+tilesY);
-			System.out.println("lapped_idct():width=    "+width);
-			System.out.println("lapped_idct():height=   "+height);
-			double debug0 = 0.0;
-			for (int i=0;i<dct_data.length;i++){
-				debug0 +=dct_data[i]*dct_data[i];
-			}
-			debug0 = Math.sqrt(debug0)/dct_data.length;
-			System.out.println("lapped_idct():debug0=   "+debug0+" (dct_data.length= "+dct_data.length+")");
-		}
-		
-		final double [] dpixels = new double[width*height];
-		final Thread[] threads = newThreadArray(threadsMax);
-		final AtomicInteger ai = new AtomicInteger(0);
-		final AtomicInteger nser = new AtomicInteger(0);
-		final int [][][] tiles_list = new int[4][][];
-		for (int n=0; n<4; n++){
-			int nx = (tilesX + 1 - (n &1)) / 2;
-			int ny = (tilesY + 1 - ((n>>1) & 1)) / 2;
-			tiles_list[n] = new int [nx*ny][2];
-			int indx = 0;
-			for (int i = 0;i < ny; i++) for (int j = 0; j < nx; j++){
-				tiles_list[n][indx][0]=2*j+(n &1);
-				tiles_list[n][indx++][1]=2*i+((n>>1) & 1);
-			}
-		}
-
-		for (int i=0; i<dpixels.length;i++) dpixels[i]= 0;
-		for (int n=0; n<4; n++){
-			nser.set(n);
-			ai.set(0);
-			for (int ithread = 0; ithread < threads.length; ithread++) {
-				threads[ithread] = new Thread() {
-					public void run() {
-						DttRad2 dtt = new DttRad2(dct_size);
-						dtt.set_window(window_type);
-						double [] tile_in = new double[dct_size * dct_size];
-						double [] tile_dct; // = new double[dct_size * dct_size];
-						double [] tile_out; //  = new double[4*dct_size * dct_size];
-						int tileY,tileX;
-						int n2 = dct_size * 2;
-						for (int nTile = ai.getAndIncrement(); nTile < tiles_list[nser.get()].length; nTile = ai.getAndIncrement()) {
-							tileX = tiles_list[nser.get()][nTile][0];
-							tileY = tiles_list[nser.get()][nTile][1];
-							for (int i = 0; i < dct_size;i++){
-								System.arraycopy(dct_data, (tileY*dct_width+tileX)*dct_size + i*dct_width, tile_in, dct_size*i, dct_size);
-							}
-							tile_dct=dtt.dttt_iv  (tile_in, 0, dct_size);
-							tile_out=dtt.unfold_tile(tile_dct, dct_size);
-							for (int i = 0; i < n2;i++){
-								int start_line = ((tileY*dct_size + i) *(tilesX+1) + tileX)*dct_size; 
-								for (int j = 0; j<n2;j++) {
-									dpixels[start_line + j] += tile_out[n2 * i + j]; //  +1.0; 
-
-								}
-							}
-
-						}
-					}
-				};
-			}		      
-			startAndJoin(threads);
-		}
-		return dpixels;
-	}
-	
-	public double [][][][] mdctDcStack(
+	public double [][][][] mdctStack(
 			final ImageStack                                 imageStack,
+			final int                                        subcamera, // 
 			final EyesisCorrectionParameters.DCTParameters   dctParameters, //
 			final EyesisDCT                                  eyesisDCT,
 			final int                                        threadsMax, // maximal step in pixels on the maxRadius for 1 angular step (i.e. 0.5)
@@ -210,27 +44,32 @@ public class ImageDtt {
 	  	  if (imageStack==null) return null;
 		  final int imgWidth=imageStack.getWidth();
 		  final int nChn=imageStack.getSize();
-		  double [][][][] dctdc_data = new double [nChn][][][];
+		  double [][][][] dct_data = new double [nChn][][][];
 		  float [] fpixels;
 		  int i,chn; //tileX,tileY;
 		  /* find number of the green channel - should be called "green", if none - use last */
 		  // Extract float pixels from inage stack, convert each to double
 
 		  EyesisDCT.DCTKernels dct_kernels = null;
-		  if (dctParameters.kernel_chn >=0 ){
-			  dct_kernels = eyesisDCT.kernels[dctParameters.kernel_chn];
+		  dct_kernels = eyesisDCT.kernels[subcamera];
+		  if (dct_kernels == null){
+			  System.out.println("No DCT kernels available for subcamera # "+subcamera);
+		  } else if (debugLevel>0){
+			  System.out.println("Using DCT kernels for subcamera # "+subcamera);
 		  }
+//		  if (dctParameters.kernel_chn >=0 ){
+//			  dct_kernels = eyesisDCT.kernels[dctParameters.kernel_chn];
+//		  }
 		  
 		  for (chn=0;chn<nChn;chn++) {
 			  fpixels= (float[]) imageStack.getPixels(chn+1);
 			  double[] dpixels = new double[fpixels.length];
 			  for (i = 0; i <fpixels.length;i++) dpixels[i] = fpixels[i];
 			  // convert each to DCT tiles
-			  dctdc_data[chn] =lapped_dctdc(
+			  dct_data[chn] =lapped_dct(
 						dpixels,
 						imgWidth,
 						dctParameters.dct_size,
-						dctParameters.subtract_dc,
 						0, //     dct_mode,    // 0: dct/dct, 1: dct/dst, 2: dst/dct, 3: dst/dst
 						dctParameters.dct_window, // final int       window_type,
 						chn,
@@ -243,15 +82,13 @@ public class ImageDtt {
 						threadsMax,  // maximal number of threads to launch                         
 						debugLevel);
 		  }
-		return dctdc_data;
+		return dct_data;
 	}
 	
-	// extract DC, result is an array [tilesY][tilesX][dct_size*dct_size+1] - last element is DC value
-	public double [][][] lapped_dctdc(
+	public double [][][] lapped_dct(
 			final double [] dpixels,
 			final int       width,
 			final int       dct_size,
-			final boolean   subtract_dc,
 			final int       dct_mode,    // 0: dct/dct, 1: dct/dst, 2: dst/dct, 3: dst/dst
 			final int       window_type,
 			final int       color,
@@ -269,12 +106,12 @@ public class ImageDtt {
 		final int tilesX=width/dct_size-1;
 		final int tilesY=height/dct_size-1;
 		final int nTiles=tilesX*tilesY; 
-		final double [][][] dctdc_data = new double[tilesY][tilesX][dct_size*dct_size+1];
+		final double [][][] dct_data = new double[tilesY][tilesX][dct_size*dct_size];
 		final Thread[] threads = newThreadArray(threadsMax);
 		final AtomicInteger ai = new AtomicInteger(0);
 		for (int tileY = 0; tileY < tilesY; tileY++){
 			for (int tileX = 0; tileX < tilesX; tileX++){
-				for (int i=0; i<dctdc_data[tileY][tileX].length;i++) dctdc_data[tileY][tileX][i]= 0.0; // actually not needed, Java initializes arrays
+				for (int i=0; i<dct_data[tileY][tileX].length;i++) dct_data[tileY][tileX][i]= 0.0; // actually not needed, Java initializes arrays
 			}
 		}
 		double [] dc = new double [dct_size*dct_size];
@@ -308,10 +145,8 @@ public class ImageDtt {
 					double [] tile_out; // = new double[dct_size * dct_size];
 					int tileY,tileX;
 					int n2 = dct_size * 2;
-					double dc;
 					double [] tile_out_copy = null;
 					showDoubleFloatArrays sdfa_instance = new showDoubleFloatArrays(); // just for debugging?
-					
 					for (int nTile = ai.getAndIncrement(); nTile < nTiles; nTile = ai.getAndIncrement()) {
 						tileY = nTile/tilesX;
 						tileX = nTile - tileY * tilesX;
@@ -435,15 +270,7 @@ public class ImageDtt {
 							}
 						}
 						tile_folded=dtt.fold_tile(tile_in, dct_size);
-						dc = 0.0;
-						if (subtract_dc) {
-							for (int i = 0; i < tile_folded.length; i++) dc+=tile_folded[i];
-							dc /= tile_folded.length;
-							for (int i = 0; i < tile_folded.length; i++) tile_folded[i] -= dc;
-						}
 						tile_out=dtt.dttt_iv  (tile_folded, dct_mode, dct_size);
-						 
-						
 						if ((dct_kernels != null) && !skip_sym){ // convolve in frequency domain with sym_kernel
 							double s0 =0;
 
@@ -512,32 +339,30 @@ public class ImageDtt {
 								System.out.println("s0="+s0+" s1="+s1+" s2="+s2+" s3="+s3);
 							}
 						}
-						System.arraycopy(tile_out, 0, dctdc_data[tileY][tileX], 0, tile_out.length);
-						dctdc_data[tileY][tileX][tile_out.length] = dc;
+						System.arraycopy(tile_out, 0, dct_data[tileY][tileX], 0, tile_out.length);
 					}
 				}
 			};
 		}		      
 		startAndJoin(threads);
-		return dctdc_data;
+		return dct_data;
 	}
 	
-	// extract DC or AC components in linescan order (for visualization)
-	public double [] lapped_dct_dcac(
-			final boolean       out_ac, // false - output DC, true - output AC
-			final double [][][] dctdc_data,
+	// extract DCT transformed parameters in linescan order (for visualization)
+	public double [] lapped_dct_dbg(
+			final double [][][] dct_data,
 			final int           threadsMax,     // maximal number of threads to launch                         
 			final int           globalDebugLevel)
 	{
-		final int tilesY=dctdc_data.length;
-		final int tilesX=dctdc_data[0].length;
+		final int tilesY=dct_data.length;
+		final int tilesX=dct_data[0].length;
 		final int nTiles=tilesX*tilesY;
-		final int dct_size = (int) Math.round(Math.sqrt(dctdc_data[0][0].length-1));
+		final int dct_size = (int) Math.round(Math.sqrt(dct_data[0][0].length));
 		final int dct_len = dct_size*dct_size;
-		final double [] dct_data = new double[tilesY*tilesX*(out_ac?dct_len:1)];
+		final double [] dct_data_out = new double[tilesY*tilesX*dct_len];
 		final Thread[] threads = newThreadArray(threadsMax);
 		final AtomicInteger ai = new AtomicInteger(0);
-		for (int i=0; i<dct_data.length;i++) dct_data[i]= 0;
+		for (int i=0; i<dct_data_out.length;i++) dct_data_out[i]= 0;
 
 		for (int ithread = 0; ithread < threads.length; ithread++) {
 			threads[ithread] = new Thread() {
@@ -546,31 +371,27 @@ public class ImageDtt {
 					for (int nTile = ai.getAndIncrement(); nTile < nTiles; nTile = ai.getAndIncrement()) {
 						tileY = nTile/tilesX;
 						tileX = nTile - tileY * tilesX;
-						if (out_ac) {
 						for (int i = 0; i < dct_size;i++){
-								System.arraycopy(dctdc_data[tileY][tileX], dct_size* i, dct_data, ((tileY*dct_size + i) *tilesX + tileX)*dct_size , dct_size);
-							}
-						} else {
-							dct_data[tileY *tilesX + tileX] =  dctdc_data[tileY][tileX][dct_len];
+							System.arraycopy(dct_data[tileY][tileX], dct_size* i, dct_data_out, ((tileY*dct_size + i) *tilesX + tileX)*dct_size , dct_size);
 						}
 					}
 				}
 			};
 		}		      
 		startAndJoin(threads);
-		return dct_data;
+		return dct_data_out;
 	}
 	
 	public void dct_lpf(
 			final double sigma,
-			final double [][][] dctdc_data,
+			final double [][][] dct_data,
 			final int       threadsMax,     // maximal number of threads to launch                         
 			final int       globalDebugLevel)
 	{
-		final int tilesY=dctdc_data.length;
-		final int tilesX=dctdc_data[0].length;
+		final int tilesY=dct_data.length;
+		final int tilesX=dct_data[0].length;
 		final int nTiles=tilesX*tilesY;
-		final int dct_size = (int) Math.round(Math.sqrt(dctdc_data[0][0].length-1));
+		final int dct_size = (int) Math.round(Math.sqrt(dct_data[0][0].length));
 		final int dct_len = dct_size*dct_size;
 		final double [] filter_direct= new double[dct_len];
 		if (sigma == 0) {
@@ -598,13 +419,12 @@ public class ImageDtt {
 			filter_direct[i] /= sum;
 		}
 		
-		if (globalDebugLevel > -1) {
+		if (globalDebugLevel > 0) {
 			for (int i=0; i<filter_direct.length;i++){
 				System.out.println("dct_lpf_psf() "+i+": "+filter_direct[i]); 
 			}
 		}
 		DttRad2 dtt = new DttRad2(dct_size);
-//		final double [] filter= dtt.dttt_iii(filter_direct);
 		final double [] filter= dtt.dttt_iiie(filter_direct);
 		final double [] dbg_filter= dtt.dttt_ii(filter);
 		
@@ -631,7 +451,7 @@ public class ImageDtt {
 						tileY = nTile/tilesX;
 						tileX = nTile - tileY * tilesX;
 						for (int i = 0; i < filter.length; i++){
-							dctdc_data[tileY][tileX][i] *= filter[i];
+							dct_data[tileY][tileX][i] *= filter[i];
 						}
 					}
 				}
@@ -641,7 +461,7 @@ public class ImageDtt {
 	}
 	
 	public double [][][][] dct_color_convert(
-			final double [][][][] dctdc_data,
+			final double [][][][] dct_data,
 			final double kr,
 			final double kb,
 			final double sigma_rb,        // blur of channels 0,1 (r,b) in addition to 2 (g)
@@ -650,10 +470,10 @@ public class ImageDtt {
 			final int       threadsMax,     // maximal number of threads to launch                         
 			final int       globalDebugLevel)
 	{
-		final int tilesY=dctdc_data[0].length;
-		final int tilesX=dctdc_data[0][0].length;
+		final int tilesY=dct_data[0].length;
+		final int tilesX=dct_data[0][0].length;
 		final int nTiles=tilesX*tilesY;
-		final int dct_size = (int) Math.round(Math.sqrt(dctdc_data[0][0][0].length-1));
+		final int dct_size = (int) Math.round(Math.sqrt(dct_data[0][0][0].length));
 		final int dct_len = dct_size*dct_size;
 		final double [][][][] yPrPb = new double [3][tilesY][tilesX][dct_len];
 		final double [][][] filters = new double [3][3][dct_len];
@@ -681,9 +501,6 @@ public class ImageDtt {
 					if (sigmas[n] == 0.0)   d = ((i == 0) && (j==0))? 1.0:0.0;
 					else                    d = Math.exp(-(i*i+j*j)/(2*sigmas[n]));
 					filters_proto_direct[n][i*dct_size+j] = d;
-//					if (i > 0) d*=2;
-//					if (j > 0) d*=2;
-//					s += d;
 				}
 				
 			}
@@ -691,7 +508,7 @@ public class ImageDtt {
 				s += norm_sym_weights[i]*filters_proto_direct[n][i];
 			}
 			
-			System.out.println("dct_color_convert(): sigmas["+n+"]="+sigmas[n]+", sum="+s);
+			if (globalDebugLevel>0) System.out.println("dct_color_convert(): sigmas["+n+"]="+sigmas[n]+", sum="+s);
 			for (int i = 0; i < dct_len; i++){
 				filters_proto_direct[n][i] /=s;
 			}
@@ -700,7 +517,7 @@ public class ImageDtt {
 		DttRad2 dtt = new DttRad2(dct_size);
 		for (int i = 0; i < filters_proto.length; i++){
 			filters_proto[i] = dtt.dttt_iiie(filters_proto_direct[i]);
-			System.out.println("filters_proto.length="+filters_proto.length+" filters_proto["+i+"].length="+filters_proto[i].length+" dct_len="+dct_len+" dct_size="+dct_size);
+			if (globalDebugLevel > 0)  System.out.println("filters_proto.length="+filters_proto.length+" filters_proto["+i+"].length="+filters_proto[i].length+" dct_len="+dct_len+" dct_size="+dct_size);
 			for (int j=0; j < dct_len; j++) filters_proto[i][j] *= 2*dct_size;  
 
 		}
@@ -751,8 +568,7 @@ public class ImageDtt {
 							for (int k = 0; k <dct_len; k++){
 								yPrPb[i][tileY][tileX][k]=0.0;
 								for (int j = 0; j < filters[i].length; j++){
-									yPrPb[i][tileY][tileX][k] += filters[i][j][k] * dctdc_data[j][tileY][tileX][k];
-//									yPrPb[i][tileY][tileX][k] += filters[i][j][k] * dctdc_data[2][tileY][tileX][k]; // make it grey level (r=g=b)
+									yPrPb[i][tileY][tileX][k] += filters[i][j][k] * dct_data[j][tileY][tileX][k];
 								}
 							}
 							
@@ -771,8 +587,9 @@ public class ImageDtt {
 	
 	
 	// Restore DC
-	public double [] lapped_idctdc(
-			final double [][][] dctdc_data,  // array [tilesY][tilesX][dct_size*dct_size+1] - last element is DC value  
+	public double [] lapped_idct(
+//			final double [][][] dctdc_data,  // array [tilesY][tilesX][dct_size*dct_size+1] - last element is DC value  
+			final double [][][] dct_data,  // array [tilesY][tilesX][dct_size*dct_size]  
 			final int       dct_size,
 			final int       window_type,
 			final int       threadsMax,  // maximal number of threads to launch                         
@@ -780,8 +597,8 @@ public class ImageDtt {
 	{
 //		final int tilesX=dct_width/dct_size;
 //		final int tilesY=dct_data.length/(dct_width*dct_size);
-		final int tilesY=dctdc_data.length;
-		final int tilesX=dctdc_data[0].length;
+		final int tilesY=dct_data.length;
+		final int tilesX=dct_data[0].length;
 
 		final int width=  (tilesX+1)*dct_size;
 		final int height= (tilesY+1)*dct_size;
@@ -806,7 +623,6 @@ public class ImageDtt {
 				tiles_list[n][indx++][1]=2*i+((n>>1) & 1);
 			}
 		}
-
 		for (int i=0; i<dpixels.length;i++) dpixels[i]= 0;
 		for (int n=0; n<4; n++){
 			nser.set(n);
@@ -824,11 +640,8 @@ public class ImageDtt {
 						for (int nTile = ai.getAndIncrement(); nTile < tiles_list[nser.get()].length; nTile = ai.getAndIncrement()) {
 							tileX = tiles_list[nser.get()][nTile][0];
 							tileY = tiles_list[nser.get()][nTile][1];
-							System.arraycopy(dctdc_data[tileY][tileX], 0, tile_in, 0, tile_in.length);
-							// will get rid of the DC eventually
-							double dc = (dctdc_data[tileY][tileX].length > tile_in.length)?dctdc_data[tileY][tileX][tile_in.length]:0.0;
+							System.arraycopy(dct_data[tileY][tileX], 0, tile_in, 0, tile_in.length);
 							tile_dct=dtt.dttt_iv  (tile_in, 0, dct_size);
-							for (int i = 0; i<tile_dct.length; i++) tile_dct[i] += dc;
 							tile_out=dtt.unfold_tile(tile_dct, dct_size);
 							for (int i = 0; i < n2;i++){
 								int start_line = ((tileY*dct_size + i) *(tilesX+1) + tileX)*dct_size; 

src/main/java/PixelMapping.java

@@ -151,23 +151,11 @@ public class PixelMapping {
     	return (this.sensors != null) && (channel>=0)  && (channel<this.sensors.length) && (this.sensors[channel]!=null);
     }
 
-/*
-    
-    public int [] channelsForSubCamera(int subCamera){
-    	if (this.sensors == null) return null;
-    	int numChannels=0;
-    	for (int i=0;i<this.sensors.length;i++) if ((this.sensors[i]!=null) &&(this.sensors[i].subcamera==subCamera)) numChannels++;
-    	int [] result=new int [numChannels];
-    	numChannels=0;
-    	for (int i=0;i<this.sensors.length;i++) if ((this.sensors[i]!=null) &&(this.sensors[i].subcamera==subCamera)) result[numChannels++]=i;
-    	return result;
-    }
-    
- */
     // Updating for nc393. subCamera here is 0..9 for Eyesis4pi393 - 0-based index of the file, so it combines physical camera (separate IP)
     // as stored in "subcamera" field of the calibration file and "sensor_port". sensor_port may start from non-0, so we need to count all combinations
-    
+    //removeUnusedSensorData xshould be off!
     public int [] channelsForSubCamera(int subCamera){
+		System.out.println("channelsForSubCamera("+subCamera+"),this.sensors.length="+this.sensors.length);
 //    	ArrayList<ArrayList<ArrayList<Integer>>> camera_IPs = new ArrayList<ArrayList<ArrayList<Integer>>>(); 
     	ArrayList<Point> cam_port = new ArrayList<Point>();
     	for (int i=0;i<this.sensors.length;i++)  if (this.sensors[i]!=null) {
@@ -175,6 +163,7 @@ public class PixelMapping {
     		if (!cam_port.contains(cp)){
     			cam_port.add(cp);
     		}
+    		System.out.println("this.sensors["+i+"]!=null, this.sensors[i].subcamera="+this.sensors[i].subcamera+", this.sensors[i].sensor_port="+this.sensors[i].sensor_port);
     	}
     	Point [] cam_port_arr = cam_port.toArray(new Point[0]);
 		Arrays.sort(cam_port_arr, new Comparator<Point>() {
@@ -183,9 +172,7 @@ public class PixelMapping {
 				return (o1.x>o2.x)? 1:((o1.x < o2.x)?-1:(o1.y > o2.y)? 1:((o1.y < o2.y)?-1:0)); 
 			}
 		});
-//		for (int i=0; i<cam_port_arr.length;i++){
-//			System.out.println("----- physical camera #"+cam_port_arr[i].x+", sensor_port="+cam_port_arr[i].y);
-//		}
+		// debugging:
 		System.out.println("----- This filename subcamera "+subCamera+": physical camera "+cam_port_arr[subCamera].x+", sensor_port "+cam_port_arr[subCamera].y);
 		if (subCamera >= cam_port_arr.length) {
 			System.out.println("Error: Subcamera "+subCamera+" > that total namera of sensor ports in the system = "+cam_port_arr.length);