Changeset 1850


Ignore:
Timestamp:
11/27/06 10:18:17 (14 years ago)
Author:
melissa
Message:
  • Switched importer to use ImageJ's RGB merging methods instead of ImageTools.make24Bits().
  • Tweaked isInterleaved in ICSReader and BaseTiffReader
  • Fixed some stuff in ImageTools.make24Bits.
Location:
trunk/loci
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/FormatReader.java

    r1838 r1850  
    689689          images[i - start] =  
    690690            ImageTools.makeImage(ImageTools.make24Bits(pix, x, y,  
    691               reader.isInterleaved(id), false), x, y); 
     691              false, false), x, y); 
    692692        } 
    693693 
  • trunk/loci/formats/ImageTools.java

    r1843 r1850  
    925925      rtn[1][i] = (byte) ((pix[i] >> 8) & 0xff); 
    926926      byte b = (byte) (pix[i] & 0xff); 
    927       rtn[0][i] = reverse ? r : b; 
    928       rtn[2][i] = reverse ? b : r; 
     927      rtn[0][i] = reverse ? b : r; 
     928      rtn[2][i] = reverse ? r : b; 
    929929    } 
    930930    return rtn; 
     
    942942    int[] rtn = new int[w * h]; 
    943943    int stride = interleaved ? w * h : 1; 
    944      
     944   
    945945    byte[] b = null; 
    946946 
     
    953953      for (int i=0; i<s.length; i++) { 
    954954        int v = s[i] & 0xffff; 
    955         if (v > 255) v = 255; 
    956955        b[i] = (byte) v; 
    957956      } 
     
    962961      for (int i=0; i<s.length; i++) { 
    963962        int value = s[i] & 0xffffffff; 
    964         if (value > 255) value = 255; 
    965963        b[i] = (byte) value; 
    966964      } 
     
    971969      for (int i=0; i<s.length; i++) { 
    972970        float value = s[i]; 
    973         if (value < 0f) value = 0f; 
    974         if (value > 255f) value = 255f; 
    975         b[i] = (byte) Math.round(value); 
     971        b[i] = (byte) (255 * value); 
    976972      } 
    977973    } 
     
    981977      for (int i=0; i<s.length; i++) { 
    982978        double value = s[i]; 
    983         if (value < 0d) value = 0d; 
    984         if (value > 255d) value = 255d; 
    985979        b[i] = (byte) Math.round(value); 
    986980      } 
     
    994988        a[j] = b[interleaved ? i*c + j : i + j*w*h]; 
    995989      } 
     990      byte tmp = a[0]; 
     991      a[0] = a[2]; 
     992      a[2] = tmp; 
    996993      rtn[i] = DataTools.bytesToInt(a, true); 
    997994    } 
    998      
     995 
    999996    return rtn; 
    1000997  } 
  • trunk/loci/formats/in/BaseTiffReader.java

    r1834 r1850  
    729729  /** Returns whether or not the channels are interleaved. */ 
    730730  public boolean isInterleaved(String id) throws FormatException, IOException { 
    731     return true; 
     731    if (!id.equals(currentId)) initFile(id); 
     732    int pi = TiffTools.getPhotometricInterpretation(ifds[0]); 
     733    return pi == TiffTools.RGB || pi == TiffTools.RGB_PALETTE ||  
     734      pi == TiffTools.CFA_ARRAY; 
    732735  } 
    733736 
  • trunk/loci/formats/in/ICSReader.java

    r1806 r1850  
    115115  /** Returns whether or not the channels are interleaved. */ 
    116116  public boolean isInterleaved(String id) throws FormatException, IOException { 
    117     return false; 
     117    return rgb; 
    118118  } 
    119119 
  • trunk/loci/plugins/Importer.java

    r1834 r1850  
    396396          if (b.length != w * h * c * bpp) { 
    397397            BufferedImage bi = r.openImage(id, j); 
    398             b = ImageTools.padImage(b, r.isInterleaved(id), c, bi.getWidth()*bpp, 
    399               w, h); 
     398            b = ImageTools.padImage(b, r.isInterleaved(id), c,  
     399              bi.getWidth()*bpp, w, h); 
    400400          } 
    401401           
     
    404404            r.isLittleEndian(id)); 
    405405 
    406           if (c == 1) { 
    407             if (pixels instanceof byte[]) { 
    408               byte[] bytes = (byte[]) pixels; 
    409               if (bytes.length > w*h) { 
    410                 byte[] tmp = bytes; 
    411                 bytes = new byte[w*h]; 
    412                 System.arraycopy(tmp, 0, bytes, 0, bytes.length); 
    413               } 
     406          if (pixels instanceof byte[]) { 
     407            byte[] bytes = (byte[]) pixels; 
     408            if (bytes.length > w*h*c) { 
     409              byte[] tmp = bytes; 
     410              bytes = new byte[w*h*c]; 
     411              System.arraycopy(tmp, 0, bytes, 0, bytes.length); 
     412            } 
     413            if (c == 1) { 
    414414              ip = new ByteProcessor(w, h, bytes, null); 
    415415              if (stackB == null) stackB = new ImageStack(w, h); 
    416416              stackB.addSlice(imageName + ":" + (j + 1), ip); 
    417417            } 
    418             else if (pixels instanceof short[]) { 
    419               short[] s = (short[]) pixels; 
    420               if (s.length > w*h) { 
    421                 short[] tmp = s; 
    422                 s = new short[w*h]; 
    423                 System.arraycopy(tmp, 0, s, 0, s.length); 
    424               } 
     418            else { 
     419              if (stackO == null) stackO = new ImageStack(w, h); 
     420              ip = new ColorProcessor(w, h); 
     421              byte[][] pix = new byte[c][w*h]; 
     422              if (r.isInterleaved(id)) { 
     423                for (int k=0; k<bytes.length; k+=c) { 
     424                  for (int l=0; l<c; l++) { 
     425                    pix[l][k / 3] = bytes[k + l]; 
     426                  } 
     427                } 
     428              } 
     429              else { 
     430                for (int k=0; k<c; k++) { 
     431                  System.arraycopy(bytes, 0, pix[k], 0, pix[k].length); 
     432                  System.arraycopy(bytes, pix[k].length, pix[k], 0,  
     433                    pix[k].length); 
     434                  System.arraycopy(bytes, 2*pix[k].length, pix[k], 0,  
     435                    pix[k].length); 
     436                } 
     437              } 
     438              ((ColorProcessor) ip).setRGB(pix[0], pix[1],  
     439                pix.length >= 3 ? pix[2] : new byte[w*h]); 
     440              stackO.addSlice(imageName + ":" + (j + 1), ip); 
     441            } 
     442          } 
     443          else if (pixels instanceof short[]) { 
     444            short[] s = (short[]) pixels; 
     445            if (s.length > w*h*c) { 
     446              short[] tmp = s; 
     447              s = new short[w*h*c]; 
     448              System.arraycopy(tmp, 0, s, 0, s.length); 
     449            } 
     450            if (c == 1) { 
    425451              ip = new ShortProcessor(w, h, s, null); 
    426452              if (stackS == null) stackS = new ImageStack(w, h); 
    427453              stackS.addSlice(imageName + ":" + (j + 1), ip); 
    428454            } 
    429             else if (pixels instanceof int[]) { 
    430               int[] ints = (int[]) pixels; 
    431               if (ints.length > w*h) { 
    432                 int[] tmp = ints; 
    433                 ints = new int[w*h]; 
    434                 System.arraycopy(tmp, 0, ints, 0, ints.length); 
    435               } 
    436               ip = new FloatProcessor(w, h, ints); 
     455            else { 
     456              if (stackO == null) stackO = new ImageStack(w, h); 
     457              short[][] pix = new short[c][w*h]; 
     458              if (r.isInterleaved(id)) { 
     459                for (int k=0; k<s.length; k+=c) { 
     460                  for (int l=0; l<c; l++) { 
     461                    pix[l][k / 3] = s[k + l]; 
     462                  } 
     463                } 
     464              } 
     465              else { 
     466                for (int k=0; k<c; k++) { 
     467                  System.arraycopy(s, k*pix[k].length, pix[k], 0,  
     468                    pix[k].length); 
     469                } 
     470              } 
     471              byte[][] bytes = new byte[c][w*h]; 
     472              for (int k=0; k<c; k++) { 
     473                ip = new ShortProcessor(w, h, pix[k], null); 
     474                ip = ip.convertToByte(true); 
     475                bytes[k] = (byte[]) ip.getPixels(); 
     476              } 
     477              ip = new ColorProcessor(w, h); 
     478              ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     479                pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     480              stackO.addSlice(imageName + ":" + (j + 1), ip); 
     481            } 
     482          } 
     483          else if (pixels instanceof int[]) { 
     484            int[] s = (int[]) pixels; 
     485            if (s.length > w*h*c) { 
     486              int[] tmp = s; 
     487              s = new int[w*h*c]; 
     488              System.arraycopy(tmp, 0, s, 0, s.length); 
     489            } 
     490            if (c == 1) { 
     491              ip = new FloatProcessor(w, h, s); 
    437492              if (stackF == null) stackF = new ImageStack(w, h); 
    438493              stackF.addSlice(imageName + ":" + (j + 1), ip); 
    439494            } 
    440             else if (pixels instanceof float[]) { 
    441               float[] f = (float[]) pixels; 
    442               if (f.length > w*h) { 
    443                 float[] tmp = f; 
    444                 f = new float[w*h]; 
    445                 System.arraycopy(tmp, 0, f, 0, f.length); 
    446               } 
     495            else { 
     496              if (stackO == null) stackO = new ImageStack(w, h); 
     497              int[][] pix = new int[c][w*h]; 
     498              if (r.isInterleaved(id)) { 
     499                for (int k=0; k<s.length; k+=c) { 
     500                  for (int l=0; l<c; l++) { 
     501                    pix[l][k / 3] = s[k + l]; 
     502                  } 
     503                } 
     504              } 
     505              else { 
     506                for (int k=0; k<c; k++) { 
     507                  System.arraycopy(s, k*pix[k].length, pix[k], 0,  
     508                    pix[k].length); 
     509                } 
     510              } 
     511              byte[][] bytes = new byte[c][w*h]; 
     512              for (int k=0; k<c; k++) { 
     513                ip = new FloatProcessor(w, h, pix[k]); 
     514                ip = ip.convertToByte(true); 
     515                bytes[k] = (byte[]) ip.getPixels(); 
     516              } 
     517              ip = new ColorProcessor(w, h); 
     518              ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     519                pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     520              stackO.addSlice(imageName + ":" + (j + 1), ip); 
     521            } 
     522          } 
     523          else if (pixels instanceof float[]) { 
     524            float[] f = (float[]) pixels; 
     525            if (f.length > w*h*c) { 
     526              float[] tmp = f; 
     527              f = new float[w*h*c]; 
     528              System.arraycopy(tmp, 0, f, 0, f.length); 
     529            } 
     530            if (c == 1) { 
    447531              ip = new FloatProcessor(w, h, f, null); 
    448532              if (stackF == null) stackF = new ImageStack(w, h); 
     
    460544              else stackF.addSlice(imageName + ":" + (j + 1), ip); 
    461545            } 
    462             else if (pixels instanceof double[]) { 
    463               double[] d = (double[]) pixels; 
    464               if (d.length > w*h) { 
    465                 double[] tmp = d; 
    466                 d = new double[w*h]; 
    467                 System.arraycopy(tmp, 0, d, 0, d.length); 
    468               } 
     546            else { 
     547              if (stackO == null) stackO = new ImageStack(w, h); 
     548              float[][] pix = new float[c][w*h]; 
     549              if (r.isInterleaved(id)) { 
     550                for (int k=0; k<f.length; k+=c) { 
     551                  for (int l=0; l<c; l++) { 
     552                    pix[l][k / 3] = f[k + l]; 
     553                  } 
     554                } 
     555              } 
     556              else { 
     557                for (int k=0; k<c; k++) { 
     558                  System.arraycopy(f, k*pix[k].length, pix[k], 0,  
     559                    pix[k].length); 
     560                } 
     561              } 
     562              byte[][] bytes = new byte[c][w*h]; 
     563              for (int k=0; k<c; k++) { 
     564                ip = new FloatProcessor(w, h, pix[k], null); 
     565                ip = ip.convertToByte(true); 
     566                bytes[k] = (byte[]) ip.getPixels(); 
     567              } 
     568              ip = new ColorProcessor(w, h); 
     569              ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     570                pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     571              stackO.addSlice(imageName + ":" + (j + 1), ip); 
     572            } 
     573          } 
     574          else if (pixels instanceof double[]) { 
     575            double[] d = (double[]) pixels; 
     576            if (d.length > w*h*c) { 
     577              double[] tmp = d; 
     578              d = new double[w*h*c]; 
     579              System.arraycopy(tmp, 0, d, 0, d.length); 
     580            } 
     581            if (c == 1) { 
    469582              ip = new FloatProcessor(w, h, d); 
    470583              if (stackF == null) stackF = new ImageStack(w, h); 
    471584              stackF.addSlice(imageName + ":" + (j + 1), ip); 
    472585            } 
    473           } 
     586            else { 
     587              if (stackO == null) stackO = new ImageStack(w, h); 
     588              double[][] pix = new double[c][w*h]; 
     589              if (r.isInterleaved(id)) { 
     590                for (int k=0; k<d.length; k+=c) { 
     591                  for (int l=0; l<c; l++) { 
     592                    pix[l][k / 3] = d[k + l]; 
     593                  } 
     594                } 
     595              } 
     596              else { 
     597                for (int k=0; k<c; k++) { 
     598                  System.arraycopy(d, k*pix[k].length, pix[k], 0,  
     599                    pix[k].length); 
     600                } 
     601              } 
     602              byte[][] bytes = new byte[c][w*h]; 
     603              for (int k=0; k<c; k++) { 
     604                ip = new FloatProcessor(w, h, pix[k]); 
     605                ip = ip.convertToByte(true); 
     606                bytes[k] = (byte[]) ip.getPixels(); 
     607              } 
     608              ip = new ColorProcessor(w, h); 
     609              ((ColorProcessor) ip).setRGB(bytes[0], bytes[1],  
     610                pix.length >= 3 ? bytes[2] : new byte[w*h]); 
     611              stackO.addSlice(imageName + ":" + (j + 1), ip); 
     612            } 
     613          } 
     614        } 
     615          /* 
    474616          if (ip == null) { 
    475617            ip = new ColorProcessor(w, h, 
     
    478620            stackO.addSlice(imageName + ":" + (j + 1), ip); 
    479621          } 
    480         } 
     622          */ 
    481623 
    482624        IJ.showStatus("Creating image"); 
Note: See TracChangeset for help on using the changeset viewer.