Changeset 4755


Ignore:
Timestamp:
01/23/09 10:57:18 (11 years ago)
Author:
melissa
Message:

Catch NumberFormatException when parsing Objective data.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/in/ZeissLSMReader.java

    r4680 r4755  
    100100  private static final int DATA_CHANNEL_NAME = 0xd0000001; 
    101101 
     102  /** Drawing element types. */ 
     103  private static final int DRAWING_ELEMENT_FLOAT_TEXT = 13; 
     104  private static final int DRAWING_ELEMENT_FLOAT_LINE = 14; 
     105  private static final int DRAWING_ELEMENT_FLOAT_SCALE_BAR = 15; 
     106  private static final int DRAWING_ELEMENT_FLOAT_OPEN_ARROW = 16; 
     107  private static final int DRAWING_ELEMENT_FLOAT_CLOSED_ARROW = 17; 
     108  private static final int DRAWING_ELEMENT_FLOAT_RECTANGLE = 18; 
     109  private static final int DRAWING_ELEMENT_FLOAT_ELLIPSE = 19; 
     110  private static final int DRAWING_ELEMENT_FLOAT_CLOSED_POLYLINE = 20; 
     111  private static final int DRAWING_ELEMENT_FLOAT_OPEN_POLYLINE = 21; 
     112  private static final int DRAWING_ELEMENT_FLOAT_CLOSED_BEZIER = 22; 
     113  private static final int DRAWING_ELEMENT_FLOAT_OPEN_BEZIER = 23; 
     114  private static final int DRAWING_ELEMENT_FLOAT_CIRCLE = 24; 
     115  private static final int DRAWING_ELEMENT_FLOAT_PALETTE = 25; 
     116  private static final int DRAWING_ELEMENT_FLOAT_POLYLINE_ARROW = 26; 
     117  private static final int DRAWING_ELEMENT_FLOAT_BEZIER_WITH_ARROW = 27; 
     118  private static final int DRAWING_ELEMENT_FLOAT_ANGLE = 28; 
     119  private static final int DRAWING_ELEMENT_FLOAT_CIRCLE_3POINT = 29; 
     120 
    102121  // -- Static fields -- 
    103122 
     
    377396 
    378397    for (int i=0; i<overlayOffsets.length; i++) { 
    379       parseOverlays(overlayOffsets[i], overlayKeys[i]); 
     398      parseOverlays(overlayOffsets[i], overlayKeys[i], store); 
    380399    } 
    381400 
     
    552571        } 
    553572        String key = getKey(prefix, entry).trim(); 
    554         if (value instanceof String) value = ((String) value).trim(); 
    555573        if (key != null) addMeta(key, value); 
     574        String v = value != null ? value.toString().trim() : ""; 
    556575 
    557576        if (key.endsWith("Acquire")) { 
    558577          Integer index = new Integer(count - 2); 
    559           Integer acquire = new Integer(value.toString()); 
     578          Integer acquire = new Integer(v); 
    560579          if (key.indexOf("Detection Channel") != -1) { 
    561580            acquireChannels.put(index, acquire); 
     
    566585        } 
    567586 
    568         float n; 
    569587        switch (entry) { 
    570588          case RECORDING_ENTRY_DESCRIPTION: 
    571             store.setImageDescription(value.toString(), 0); 
     589            store.setImageDescription(v, 0); 
    572590            break; 
    573591          case RECORDING_ENTRY_OBJECTIVE: 
    574             String[] tokens = value.toString().split(" "); 
     592            String[] tokens = v.split(" "); 
    575593            StringBuffer model = new StringBuffer(); 
    576594            int next = 0; 
     
    584602              String mag = p.substring(0, p.indexOf("/") - 1); 
    585603              String na = p.substring(p.indexOf("/") + 1); 
    586               store.setObjectiveNominalMagnification(new Integer(mag), 0, 0); 
    587               store.setObjectiveLensNA(new Float(na), 0, 0); 
     604              try { 
     605                store.setObjectiveNominalMagnification(new Integer(mag), 0, 0); 
     606              } 
     607              catch (NumberFormatException e) { } 
     608              try { 
     609                store.setObjectiveLensNA(new Float(na), 0, 0); 
     610              } 
     611              catch (NumberFormatException e) { } 
    588612            } 
    589613            if (next < tokens.length) { 
    590614              store.setObjectiveImmersion(tokens[next++], 0, 0); 
    591615            } 
     616            else store.setObjectiveImmersion("Unknown", 0, 0); 
    592617            boolean iris = false; 
    593618            if (next < tokens.length) { 
     
    595620            } 
    596621            store.setObjectiveIris(new Boolean(iris), 0, 0); 
     622            store.setObjectiveCorrection("Unknown", 0, 0); 
    597623 
    598624            // link Objective to Image 
     
    602628            break; 
    603629          case TRACK_ENTRY_TIME_BETWEEN_STACKS: 
    604             store.setDimensionsTimeIncrement( 
    605               new Float(value.toString()), 0, 0); 
     630            try { 
     631              store.setDimensionsTimeIncrement(new Float(v), 0, 0); 
     632            } 
     633            catch (NumberFormatException e) { } 
    606634            break; 
    607635          case LASER_ENTRY_NAME: 
    608             String medium = value.toString(); 
     636            String medium = v; 
    609637            String laserType = null; 
    610638 
     
    644672          //case LASER_POWER: 
    645673            // TODO: this is a setting, not a fixed value 
    646             //n = Float.parseFloat(value.toString()); 
    647             //store.setLaserPower(new Float(n), 0, count - 1); 
     674            //store.setLaserPower(new Float(v), 0, count - 1); 
    648675            //break; 
    649676          case CHANNEL_ENTRY_DETECTOR_GAIN: 
    650             //n = Float.parseFloat(value.toString()); 
    651             //store.setDetectorSettingsGain(new Float(n), 0, nextGain++); 
     677            //store.setDetectorSettingsGain(new Float(v), 0, nextGain++); 
    652678            break; 
    653679          case CHANNEL_ENTRY_PINHOLE_DIAMETER: 
    654             n = Float.parseFloat(value.toString()); 
    655             channelData.put("pinhole " + count, new Float(n)); 
     680            try { 
     681              channelData.put("pinhole " + count, new Float(v)); 
     682            } 
     683            catch (NumberFormatException e) { } 
    656684            break; 
    657685          case ILLUM_CHANNEL_WAVELENGTH: 
    658             n = Float.parseFloat(value.toString()); 
    659             channelData.put("em " + count, new Integer((int) n)); 
    660             channelData.put("ex " + count, new Integer((int) n)); 
     686            try { 
     687              Integer wave = new Integer((int) Float.parseFloat(v)); 
     688              channelData.put("em " + count, wave); 
     689              channelData.put("ex " + count, wave); 
     690            } 
     691            catch (NumberFormatException e) { } 
    661692            break; 
    662693          case START_TIME: 
    663694            // date/time on which the first pixel was acquired, in days 
    664695            // since 30 December 1899 
    665             double time = Double.parseDouble(value.toString()); 
     696            double time = Double.parseDouble(v); 
    666697            store.setImageCreationDate(DataTools.convertDate( 
    667698              (long) (time * 86400000), DataTools.MICROSOFT), 0); 
     
    669700            break; 
    670701          case DATA_CHANNEL_NAME: 
    671             channelData.put("name " + count, value.toString()); 
     702            channelData.put("name " + count, v); 
    672703            break; 
    673704        } 
     
    804835    for (int i=0; i<ifds.length; i++) { 
    805836      long subFileType = TiffTools.getIFDLongValue(ifds[i], 
    806         TiffTools.NEW_SUBFILE_TYPE, true, 0); 
     837        TiffTools.NEW_SUBFILE_TYPE, false, 0); 
    807838 
    808839      if (subFileType == 0) { 
     
    839870 
    840871  /** Parses overlay-related fields. */ 
    841   protected void parseOverlays(long data, String suffix) throws IOException { 
     872  protected void parseOverlays(long data, String suffix, MetadataStore store) 
     873    throws IOException 
     874  { 
    842875    if (data == 0) return; 
    843876 
     
    852885    put("Measure-" + suffix, idata); 
    853886    in.skipBytes(8); 
    854     put("ColorRed-" + suffix, in.read()); 
    855     put("ColorGreen-" + suffix, in.read()); 
    856     put("ColorBlue-" + suffix, in.read()); 
    857     in.skipBytes(1); 
     887    int packedColor = in.readInt(); 
     888    put("ColorRed-" + suffix, packedColor & 0xff); 
     889    put("ColorGreen-" + suffix, (packedColor & 0xff00) >> 8); 
     890    put("ColorBlue-" + suffix, (packedColor & 0xff0000) >> 16); 
    858891 
    859892    put("Valid-" + suffix, in.readInt()); 
     
    888921    put("Rectangle-" + suffix, in.read()); 
    889922    put("Line-" + suffix, in.read()); 
     923 
     924    in.skipBytes(28); 
     925 
     926    // read drawing elements and place them in the MetadataStore 
     927 
    890928    /* 
    891     try { 
    892       int drawingEl = (size - 194) / nde; 
    893       if (drawingEl <= 0) return; 
    894       if (DataTools.swap(nde) < nde) nde = DataTools.swap(nde); 
    895       for (int i=0; i<nde; i++) { 
    896         put("DrawingElement" + i + "-" + suffix, in.readString(drawingEl)); 
    897       } 
    898     } 
    899     catch (ArithmeticException exc) { 
    900       if (debug) trace(exc); 
     929    for (int i=0; i<nde; i++) { 
     930      int type = in.readInt(); 
     931      in.skipBytes(4); 
     932      int lineWidth = in.readInt(); 
     933      int measureFlags = in.readInt(); 
     934      double textStartX = in.readDouble(); 
     935      double textStartY = in.readDouble(); 
     936      int color = in.readInt(); // ABGR 
     937      int valid = in.readInt(); 
     938      int knotWidth = in.readInt(); 
     939      in.skipBytes(4); 
     940      int fontHeight = in.readInt(); 
     941      int fontWidth = in.readInt(); 
     942      in.skipBytes(8); 
     943      boolean italicFont = in.readInt() != 0; 
     944      boolean underlineFont = in.readInt() != 0; 
     945      boolean strikeFont = in.readInt() != 0; 
     946      in.skipBytes(20); 
     947      String fontName = in.readString(64); 
     948      boolean enabled = in.readShort() == 0; 
     949      in.skipBytes(36); 
     950 
     951      switch (type) { 
     952        case DRAWING_ELEMENT_FLOAT_TEXT: 
     953          java.awt.geom.Point2D.Double origin = readPoint(in); 
     954          // String text 
     955          break; 
     956        case DRAWING_ELEMENT_FLOAT_LINE: 
     957        case DRAWING_ELEMENT_FLOAT_SCALE_BAR: 
     958        case DRAWING_ELEMENT_FLOAT_OPEN_ARROW: 
     959        case DRAWING_ELEMENT_FLOAT_CLOSED_ARROW: 
     960          in.skipBytes(4); 
     961          java.awt.geom.Point2D.Double start = readPoint(in); 
     962          java.awt.geom.Point2D.Double end = readPoint(in); 
     963 
     964          store.setLinex1(String.valueOf(start.x), 0, 0, i); 
     965          store.setLiney1(String.valueOf(start.y), 0, 0, i); 
     966          store.setLinex2(String.valueOf(end.x), 0, 0, i); 
     967          store.setLiney2(String.valueOf(end.y), 0, 0, i); 
     968 
     969          break; 
     970        case DRAWING_ELEMENT_FLOAT_RECTANGLE: 
     971        case DRAWING_ELEMENT_FLOAT_PALETTE: 
     972          in.skipBytes(4); 
     973          // two corners are diagonally arranged 
     974          java.awt.geom.Point2D.Double firstCorner = readPoint(in); 
     975          java.awt.geom.Point2D.Double secondCorner = readPoint(in); 
     976          double width = secondCorner.x - firstCorner.x; 
     977          double height = secondCorner.y - firstCorner.y; 
     978 
     979          store.setRectx(String.valueOf(firstCorner.x), 0, 0, i); 
     980          store.setRecty(String.valueOf(firstCorner.y), 0, 0, i); 
     981          store.setRectwidth(String.valueOf(width), 0, 0, i); 
     982          store.setRectheight(String.valueOf(height), 0, 0, i); 
     983          break; 
     984        case DRAWING_ELEMENT_FLOAT_ELLIPSE: 
     985          in.skipBytes(4); 
     986          java.awt.geom.Point2D.Double axisIntercept1 = readPoint(in); 
     987          java.awt.geom.Point2D.Double axisIntercept2 = readPoint(in); 
     988          java.awt.geom.Point2D.Double axisIntercept3 = readPoint(in); 
     989          java.awt.geom.Point2D.Double axisIntercept4 = readPoint(in); 
     990          // TODO 
     991          break; 
     992        case DRAWING_ELEMENT_FLOAT_CIRCLE: 
     993          in.skipBytes(4); 
     994          java.awt.geom.Point2D.Double center = readPoint(in); 
     995          java.awt.geom.Point2D.Double point = readPoint(in); 
     996 
     997          store.setCirclecx(String.valueOf(center.x), 0, 0, i); 
     998          store.setCirclecy(String.valueOf(center.y), 0, 0, i); 
     999          store.setCircler(String.valueOf(center.distance(point)), 0, 0, i); 
     1000 
     1001          break; 
     1002        case DRAWING_ELEMENT_FLOAT_CIRCLE_3POINT: 
     1003          in.skipBytes(4); 
     1004          // coordinates of points on the perimeter 
     1005          java.awt.geom.Point2D.Double a = readPoint(in); 
     1006          java.awt.geom.Point2D.Double b = readPoint(in); 
     1007          java.awt.geom.Point2D.Double c = readPoint(in); 
     1008 
     1009          double temp = b.x * b.x + b.y * b.y; 
     1010          double ab = (a.x * a.x + a.y * a.y - temp) / 2.0; 
     1011          double bc = (temp - c.x * c.x - c.y * c.y) / 2.0; 
     1012          double determinant = 
     1013            1 / ((a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y)); 
     1014          double centerX = (ab * (b.y - c.y) - bc * (a.y - b.y)) * determinant; 
     1015          double centerY = ((a.x - b.x) * bc - (b.x - c.x) * ab) * determinant; 
     1016          double radius = 
     1017            Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2)); 
     1018 
     1019          store.setCirclecx(String.valueOf(centerX), 0, 0, i); 
     1020          store.setCirclecy(String.valueOf(centerY), 0, 0, i); 
     1021          store.setCircler(String.valueOf(radius), 0, 0, i); 
     1022 
     1023          break; 
     1024        case DRAWING_ELEMENT_FLOAT_ANGLE: 
     1025          in.skipBytes(4); 
     1026          a = readPoint(in); 
     1027          b = readPoint(in); 
     1028          c = readPoint(in); 
     1029          break; 
     1030        case DRAWING_ELEMENT_FLOAT_CLOSED_POLYLINE: 
     1031        case DRAWING_ELEMENT_FLOAT_OPEN_POLYLINE: 
     1032        case DRAWING_ELEMENT_FLOAT_POLYLINE_ARROW: 
     1033          int nKnots = in.readInt(); 
     1034          java.awt.geom.Point2D.Double[] vertices = 
     1035            new java.awt.geom.Point2D.Double[nKnots]; 
     1036          for (int q=0; q<nKnots; q++) { 
     1037            vertices[q] = readPoint(in); 
     1038          } 
     1039          break; 
     1040        case DRAWING_ELEMENT_FLOAT_CLOSED_BEZIER: 
     1041        case DRAWING_ELEMENT_FLOAT_OPEN_BEZIER: 
     1042        case DRAWING_ELEMENT_FLOAT_BEZIER_WITH_ARROW: 
     1043          nKnots = in.readInt(); 
     1044          // these are the endpoints of cubic Bezier segments 
     1045          // the control points are calculated assuming equidistant 
     1046          // parameterization of the curve 
     1047          java.awt.geom.Point2D.Double[] endpoints = 
     1048            new java.awt.geom.Point2D.Double[nKnots]; 
     1049          for (int q=0; q<nKnots; q++) { 
     1050            endpoints[q] = readPoint(in); 
     1051          } 
     1052          break; 
     1053      } 
    9011054    } 
    9021055    */ 
     1056  } 
     1057 
     1058  private java.awt.geom.Point2D.Double readPoint(RandomAccessStream in) 
     1059    throws IOException 
     1060  { 
     1061    java.awt.geom.Point2D.Double p = new java.awt.geom.Point2D.Double(); 
     1062    p.x = in.readDouble(); 
     1063    p.y = in.readDouble(); 
     1064    return p; 
    9031065  } 
    9041066 
Note: See TracChangeset for help on using the changeset viewer.