Пример #1
0
  /**
   * Get mean covariance matrix C2 for given pixel.
   *
   * @param x X coordinate of the given pixel.
   * @param y Y coordinate of the given pixel.
   * @param halfWindowSizeX The sliding window width /2
   * @param halfWindowSizeY The sliding window height /2
   * @param sourceImageWidth Source image width.
   * @param sourceImageHeight Source image height.
   * @param sourceProductType The source product type.
   * @param sourceTiles The source tiles for all bands.
   * @param dataBuffers Source tile data buffers.
   * @param Cr The real part of the mean covariance matrix.
   * @param Ci The imaginary part of the mean covariance matrix.
   */
  public static void getMeanCovarianceMatrixC2(
      final int x,
      final int y,
      final int halfWindowSizeX,
      final int halfWindowSizeY,
      final int sourceImageWidth,
      final int sourceImageHeight,
      final PolBandUtils.MATRIX sourceProductType,
      final Tile[] sourceTiles,
      final ProductData[] dataBuffers,
      final double[][] Cr,
      final double[][] Ci) {

    final double[][] tempCr = new double[2][2];
    final double[][] tempCi = new double[2][2];

    final int xSt = Math.max(x - halfWindowSizeX, 0);
    final int xEd = Math.min(x + halfWindowSizeX, sourceImageWidth - 1);
    final int ySt = Math.max(y - halfWindowSizeY, 0);
    final int yEd = Math.min(y + halfWindowSizeY, sourceImageHeight - 1);
    final int num = (yEd - ySt + 1) * (xEd - xSt + 1);

    final TileIndex srcIndex = new TileIndex(sourceTiles[0]);

    final Matrix CrMat = new Matrix(2, 2);
    final Matrix CiMat = new Matrix(2, 2);

    if (sourceProductType == PolBandUtils.MATRIX.C2) {

      for (int yy = ySt; yy <= yEd; ++yy) {
        srcIndex.calculateStride(yy);
        for (int xx = xSt; xx <= xEd; ++xx) {
          getCovarianceMatrixC2(srcIndex.getIndex(xx), dataBuffers, tempCr, tempCi);
          CrMat.plusEquals(new Matrix(tempCr));
          CiMat.plusEquals(new Matrix(tempCi));
        }
      }

    } else if (sourceProductType == PolBandUtils.MATRIX.LCHCP
        || sourceProductType == PolBandUtils.MATRIX.RCHCP
        || sourceProductType == PolBandUtils.MATRIX.DUAL_HH_HV
        || sourceProductType == PolBandUtils.MATRIX.DUAL_VH_VV
        || sourceProductType == PolBandUtils.MATRIX.DUAL_HH_VV) {

      final double[] tempKr = new double[2];
      final double[] tempKi = new double[2];

      for (int yy = ySt; yy <= yEd; ++yy) {
        srcIndex.calculateStride(yy);
        for (int xx = xSt; xx <= xEd; ++xx) {
          getScatterVector(srcIndex.getIndex(xx), dataBuffers, tempKr, tempKi);
          computeCovarianceMatrixC2(tempKr, tempKi, tempCr, tempCi);
          CrMat.plusEquals(new Matrix(tempCr));
          CiMat.plusEquals(new Matrix(tempCi));
        }
      }

    } else {
      throw new OperatorException("getMeanCovarianceMatrixC2 not implemented for raw dual pol");
    }

    CrMat.timesEquals(1.0 / num);
    CiMat.timesEquals(1.0 / num);
    for (int i = 0; i < 2; i++) {
      Cr[i][0] = CrMat.get(i, 0);
      Ci[i][0] = CiMat.get(i, 0);

      Cr[i][1] = CrMat.get(i, 1);
      Ci[i][1] = CiMat.get(i, 1);
    }
  }
Пример #2
0
  /**
   * Called by the framework in order to compute a tile for the given target band.
   *
   * <p>The default implementation throws a runtime exception with the message "not implemented".
   *
   * @param targetBand The target band.
   * @param targetTile The current tile associated with the target band to be computed.
   * @param pm A progress monitor which should be used to determine computation cancelation
   *     requests.
   * @throws org.esa.snap.framework.gpf.OperatorException If an error occurs during computation of
   *     the target raster.
   */
  public void computeTile(Band targetBand, Tile targetTile, ProgressMonitor pm)
      throws OperatorException {

    final Rectangle targetTileRectangle = targetTile.getRectangle();
    final int x0 = targetTileRectangle.x;
    final int y0 = targetTileRectangle.y;
    final int w = targetTileRectangle.width;
    final int h = targetTileRectangle.height;

    Tile sourceRaster1 = null;
    ProductData srcData1 = null;
    ProductData srcData2 = null;
    Band sourceBand1 = null;

    final String[] srcBandNames = targetBandNameToSourceBandName.get(targetBand.getName());
    if (srcBandNames.length == 1) {
      sourceBand1 = sourceProduct.getBand(srcBandNames[0]);
      sourceRaster1 = calibrationOp.getSourceTile(sourceBand1, targetTileRectangle);
      srcData1 = sourceRaster1.getDataBuffer();
    } else {
      sourceBand1 = sourceProduct.getBand(srcBandNames[0]);
      final Band sourceBand2 = sourceProduct.getBand(srcBandNames[1]);
      sourceRaster1 = calibrationOp.getSourceTile(sourceBand1, targetTileRectangle);
      final Tile sourceRaster2 = calibrationOp.getSourceTile(sourceBand2, targetTileRectangle);
      srcData1 = sourceRaster1.getDataBuffer();
      srcData2 = sourceRaster2.getDataBuffer();
    }

    final Unit.UnitType bandUnit = Unit.getUnitType(sourceBand1);

    // copy band if unit is phase
    if (bandUnit == Unit.UnitType.PHASE) {
      targetTile.setRawSamples(sourceRaster1.getRawSamples());
      return;
    }

    final ProductData trgData = targetTile.getDataBuffer();
    final TileIndex srcIndex = new TileIndex(sourceRaster1);
    final TileIndex tgtIndex = new TileIndex(targetTile);

    final int maxY = y0 + h;
    final int maxX = x0 + w;

    double dn = 0, dn2 = 0, sigma, i, q;
    int srcIdx, tgtIdx;

    for (int y = y0; y < maxY; ++y) {
      srcIndex.calculateStride(y);
      tgtIndex.calculateStride(y);

      for (int x = x0; x < maxX; ++x) {
        srcIdx = srcIndex.getIndex(x);
        tgtIdx = tgtIndex.getIndex(x);

        if (bandUnit == Unit.UnitType.AMPLITUDE) {
          dn = srcData1.getElemDoubleAt(srcIdx);
          dn2 = dn * dn;
        } else if (bandUnit == Unit.UnitType.INTENSITY) {
          dn2 = srcData1.getElemDoubleAt(srcIdx);
        } else if (bandUnit == Unit.UnitType.REAL || bandUnit == Unit.UnitType.IMAGINARY) {
          if (outputImageInComplex) {
            dn = srcData1.getElemDoubleAt(srcIdx);
          } else {
            i = srcData1.getElemDoubleAt(srcIdx);
            q = srcData2.getElemDoubleAt(srcIdx);
            dn2 = i * i + q * q;
          }
        } else {
          throw new OperatorException("ALOS Calibration: unhandled unit");
        }

        if (isComplex && outputImageInComplex) {
          sigma = dn * Math.sqrt(calibrationFactor);
        } else {
          sigma = dn2 * calibrationFactor;
        }

        if (outputImageScaleInDb) { // convert calibration result to dB
          if (sigma < underFlowFloat) {
            sigma = -underFlowFloat;
          } else {
            sigma = 10.0 * Math.log10(sigma);
          }
        }

        trgData.setElemDoubleAt(tgtIdx, sigma);
      }
    }
  }