import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
public static void main(String[] args) {
    try {
        Product product = ProductIO.readProduct("C:/Projects/BEAM/data/MER_RR__1P_A.N1");
        int width = product.getSceneRasterWidth();
        int height = product.getSceneRasterHeight();
        Band band = product.getBand("radiance_13");
        float[] scan = new float[width];
        for (int y = 0; y < height; y += 100) {
            band.readPixels(0, y, width, 1, scan, ProgressMonitor.NULL);
            for (int x = 0; x < width; x += 100) {
                float value = scan[x];
                System.out.println(value + " ");
            }
        }
        System.out.println();
        product.dispose();
    } catch (IOException e) {
        e.printStackTrace();  //To change body of catch statement use Options | File Templates.
    }

}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private void adjustImageInfos(RasterDataNode raster) {
    if (!isAdjustingImageInfos) {
        try {
            isAdjustingImageInfos = true;
            final String variableName = AbstractTimeSeries.rasterToVariableName(raster.getName());
            final List<Band> bandList = getBandsForVariable(variableName);
            final ImageInfo imageInfo = raster.getImageInfo(ProgressMonitor.NULL);
            if (imageInfo != null) {
                for (Band band : bandList) {
                    if (band != raster) {
                        band.setImageInfo(imageInfo.createDeepCopy());
                    }
                }
            }
        } finally {
            isAdjustingImageInfos = false;
        }
    }
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private static void nomalizeHSVExpressions(final Product product, String[] hsvExpressions) {
    // normalize
    //range = max - min;
    //normvalue = min(max(((v- min)/range),0), 1);
    boolean modified = product.isModified();

    int i = 0;
    for (String exp : hsvExpressions) {
        if (exp.isEmpty()) continue;

        final String checkForNoDataValue = "";//getCheckForNoDataExpression(product, exp);

        final Band virtBand = createVirtualBand(product, exp, "tmpVirtBand" + i);

        final Stx stx = virtBand.getStx(false, ProgressMonitor.NULL);
        if (stx != null) {
            final double min = stx.getMinimum();
            final double range = stx.getMaximum() - min;
            hsvExpressions[i] = checkForNoDataValue + "min(max((((" + exp + ")- " + min + ")/" + range + "), 0), 1)";
        }
        product.removeBand(virtBand);
        ++i;
    }
    product.setModified(modified);
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
public void writeBandRasterData(Band sourceBand, int sourceOffsetX, int sourceOffsetY, int sourceWidth, int sourceHeight, ProductData sourceBuffer, ProgressMonitor pm) throws IOException {
    final Product sourceProduct = sourceBand.getProduct();
    final int numBands = sourceProduct.getNumBands();
    boolean shouldFinalize = numBands == processedCount.get();
    if (!shouldFinalize) {
        if (!this.processedBands.containsKey(sourceBand)) {
            this.processedBands.put(sourceBand, getScaledImage(sourceBand));
            processedCount.incrementAndGet();
            shouldFinalize = numBands == processedCount.get();
        }
        if (shouldFinalize) {
            finalizeWrite();
        }
    }
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
public void start() {
    Path sourceDirPath = ResourceInstaller.findModuleCodeBasePath(getClass()).resolve("auxdata/openjpeg");
    Path auxdataDirectory = OpenJpegExecRetriever.getOpenJPEGAuxDataPath();
    if (auxdataDirectory == null) {
        SystemUtils.LOG.severe("OpenJPEG configuration error: failed to retrieve auxdata path");
        return;
    }
    final ResourceInstaller resourceInstaller = new ResourceInstaller(sourceDirPath, auxdataDirectory);

    try {
        resourceInstaller.install(".*", ProgressMonitor.NULL);
        fixUpPermissions(auxdataDirectory);
    } catch (IOException e) {
        SystemUtils.LOG.severe("OpenJPEG configuration error: failed to create " + auxdataDirectory);
        return;
    }
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private static void loadImage(final Product product, final Quicklook quicklook) {
    final StatusProgressMonitor qlPM = new StatusProgressMonitor(StatusProgressMonitor.TYPE.SUBTASK);
    qlPM.beginTask("Creating quicklook " + product.getName() + "... ", 100);

    ProgressMonitorSwingWorker<BufferedImage, Object> loader = new ProgressMonitorSwingWorker<BufferedImage, Object>
            (SnapApp.getDefault().getMainFrame(), "Loading quicklook image...") {

        @Override
        protected BufferedImage doInBackground(com.bc.ceres.core.ProgressMonitor pm) throws Exception {

            return quicklook.getImage(qlPM);
        }

        @Override
        protected void done() {
            qlPM.done();
        }
    };
    loader.execute();
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private VectorDataNode readGeometry(final SnapApp snapApp,
                                    final File file,
                                    final Product product)
        throws IOException, ExecutionException, InterruptedException {

    ProgressMonitorSwingWorker<VectorDataNode, Object> worker = new ProgressMonitorSwingWorker<VectorDataNode, Object>(snapApp.getMainFrame(), "Loading vector data") {
        @Override
        protected VectorDataNode doInBackground(ProgressMonitor pm) throws Exception {
            return reader.readVectorDataNode(file, product, pm);
        }

        @Override
        protected void done() {
            super.done();
        }
    };

    worker.executeWithBlocking();
    return worker.get();
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
public void setBands(Band[] bands) {
    Debug.assertNotNull(bands);
    this.bands = bands.clone();
    Arrays.sort(this.bands, new Comparator<Band>() {
        @Override
        public int compare(Band band1, Band band2) {
            final float v = band1.getSpectralWavelength() - band2.getSpectralWavelength();
            return v < 0.0F ? -1 : v > 0.0F ? 1 : 0;
        }
    });
    if (wavelengths == null || wavelengths.length != this.bands.length) {
        wavelengths = new double[this.bands.length];
    }
    if (energies == null || energies.length != this.bands.length) {
        energies = new double[this.bands.length];
    }
    for (int i = 0; i < wavelengths.length; i++) {
        wavelengths[i] = this.bands[i].getSpectralWavelength();
        energies[i] = 0.0f;
    }
    Range.computeRangeDouble(wavelengths, IndexValidator.TRUE, wavelengthRange, ProgressMonitor.NULL);
    Range.computeRangeDouble(energies, IndexValidator.TRUE, energyRange, ProgressMonitor.NULL);
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@SuppressWarnings({"MethodWithMoreThanThreeNegations"})
private boolean allProductsOnSameGrid() {
    Product refProduct = null;
    final List<ProductLocation> productLocations = getAssistantModel().getProductLocationsModel().getProductLocations();
    for (ProductLocation productLocation : productLocations) {
        for (Product product : productLocation.getProducts(ProgressMonitor.NULL).values()) {
            if (refProduct != null) {
                if (product != null && !refProduct.isCompatibleProduct(product, 0.1E-4f)) {
                    return false;
                }
            } else {
                if (product != null) {
                    refProduct = product;
                }
            }
        }
    }
    return true;
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private void setImage(final Product product, final Quicklook quicklook) {

        final BufferedImage img;
        if(quicklook != null && (quicklook.hasImage() || quicklook.hasCachedImage())) {
            img = quicklook.getImage(ProgressMonitor.NULL);
        } else {
            img = noDataImage;
        }

        if(currentProduct == product && imgPanel.getImage() == img) {
            return;
        }
        currentProduct = product;
        nameLabel.setText(product.getDisplayName());
        imgPanel.setImage(img);

        updateButtons();
    }
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
protected Object doInBackground(ProgressMonitor pm) throws Exception {
    UIUtils.setRootFrameWaitCursor(ImageInfoEditor2.this);
    if (parentForm.getFormModel().isValid()) {
        final RasterDataNode[] rasters = parentForm.getFormModel().getRasters();
        try {
            pm.beginTask("Computing statistics", rasters.length);
            for (RasterDataNode raster : rasters) {
                raster.getStx(true, SubProgressMonitor.create(pm, 1));
            }
        } finally {
            pm.done();
        }
    }
    return null;
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private void createS2LookupTable() throws IOException {
    File lutFile;
    URL lutResource;
    if (pathToLut != null && (new File(pathToLut)).exists()) {
        lutFile = new File(pathToLut);
    } else if ((lutResource = S2LutAccessor.class.getResource("sentinel-2a_lut_smsi_v0.6.memmap.d")) != null) {
        // search in resources as backup
        lutFile = new File(lutResource.getPath());
    } else {
        throw new IOException("");
    }

    S2LutAccessor s2LutAccessor = new S2LutAccessor(lutFile);
    s2Lut = s2LutAccessor.readLut(ProgressMonitor.NULL);
    aotGrid = s2Lut.getDimension(1).getSequence();
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
public void computeTile(Band targetBand, Tile targetTile, ProgressMonitor pm) throws OperatorException {
    Rectangle tarRec = targetTile.getRectangle();
    String targetBandName = targetBand.getName();
    final Rectangle srcRec = calcSourceRectangle(tarRec);

    Band sourceBand = lowresProduct.getBand(targetBandName);
    Tile sourceTile = getSourceTile(sourceBand, srcRec);
    Tile validTile = getSourceTile(validBand, tarRec);

    if (!targetBand.isFlagBand()) {
        upscaleTileBilinear(sourceTile, validTile, targetTile, tarRec);
    } else {
        upscaleFlagCopy(sourceTile, targetTile, tarRec);
    }
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private ProductSceneImage createProductSceneImageRGB(String name, final Product product, String[] rgbaExpressions,
                                                     ProgressMonitor pm) throws Exception {
    Band[] rgbBands = null;
    boolean errorOccurred = false;
    ProductSceneImage productSceneImage = null;
    try {
        pm.beginTask("Creating RGB image...", 2);
        rgbBands = allocateRgbBands(product, rgbaExpressions);
        productSceneImage = new ProductSceneImage(name, rgbBands[0],
                                                  rgbBands[1],
                                                  rgbBands[2],
                                                  SnapApp.getDefault().getPreferencesPropertyMap(),
                                                  SubProgressMonitor.create(pm, 1));
        productSceneImage.initVectorDataCollectionLayer();
        productSceneImage.initMaskCollectionLayer();
    } catch (Exception e) {
        errorOccurred = true;
        throw e;
    } finally {
        pm.done();
        if (rgbBands != null) {
            releaseRgbBands(rgbBands, errorOccurred);
        }
    }
    return productSceneImage;
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
public VectorDataNode readVectorDataNode(File file, Product product, ProgressMonitor pm) throws IOException {

    DefaultFeatureCollection featureCollection = FeatureUtils.loadShapefileForProduct(file,
                                                                                      product,
                                                                                      crsProvider,
                                                                                      pm);
    Style[] styles = SLDUtils.loadSLD(file);
    ProductNodeGroup<VectorDataNode> vectorDataGroup = product.getVectorDataGroup();
    String name = VectorDataNodeImporter.findUniqueVectorDataNodeName(featureCollection.getSchema().getName().getLocalPart(),
                                                                      vectorDataGroup);
    if (styles.length > 0) {
        SimpleFeatureType featureType = SLDUtils.createStyledFeatureType(featureCollection.getSchema());


        VectorDataNode vectorDataNode = new VectorDataNode(name, featureType);
        DefaultFeatureCollection styledCollection = vectorDataNode.getFeatureCollection();
        String defaultCSS = vectorDataNode.getDefaultStyleCss();
        SLDUtils.applyStyle(styles[0], defaultCSS, featureCollection, styledCollection);
        return vectorDataNode;
    } else {
        return new VectorDataNode(name, featureCollection);
    }
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private List<Product> getAllProducts(ProgressMonitor pm) {
    List<Product> result = new ArrayList<>();
    pm.beginTask("Scanning product locations ...", productLocationList.size());
    try {
        for (ProductLocation productLocation : productLocationList) {
            if (pm.isCanceled()) {
                break;
            }
            for (Product product : productLocation.getProducts(ProgressMonitor.NULL).values()) {
                result.add(product);
            }
            pm.worked(1);
        }
    } finally {
        pm.done();
    }
    return result;
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
public JToolTip createToolTip() {
    if(!thumbnail.hasImage() || !thumbnail.hasCachedImage()) {
        return super.createToolTip();
    }
    final BufferedImage thumbnailImage = thumbnail.getImage(ProgressMonitor.NULL);

    BufferedImage img = new FixedSizeThumbnailMaker()
            .size(imgWidth*3, imgHeight*3)
            .keepAspectRatio(true)
            .fitWithinDimensions(true)
            .make(thumbnailImage);

    final JToolTip toolTip = new JToolTip() {
        {
            setLayout(new BorderLayout());
            add(new JLabel(new ImageIcon(img)));
        }
        public Dimension getPreferredSize() {
            return new Dimension(img.getWidth(), img.getHeight());
        }
    };
    return toolTip;
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private void reprojectProducts(List<Product> allProducts, ProgressMonitor pm) {
    pm.beginTask("Reprojecting source products...", allProducts.size());
    try {
        for (Product product : allProducts) {
            if (pm.isCanceled()) {
                return;
            }
            if (!product.isCompatibleProduct(tsProduct, LAT_LON_EPSILON)) {
                HashMap<String, Product> productToBeReprojectedMap = new HashMap<>();
                productToBeReprojectedMap.put("source", product);
                productToBeReprojectedMap.put("collocateWith", tsProduct);
                final Product collocatedProduct = GPF.createProduct("Reproject", createProjectionParameters(), productToBeReprojectedMap);
                collocatedProduct.setStartTime(product.getStartTime());
                collocatedProduct.setEndTime(product.getEndTime());
                product = collocatedProduct;
            }
            productTimeMap.put(formatTimeString(product), product);
            pm.worked(1);
        }
    } finally {
        pm.done();
    }
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
private void reprojectSourceProducts(ProgressMonitor pm) {
    final ProductLocationsPaneModel productLocationsModel = getAssistantModel().getProductLocationsModel();
    final List<ProductLocation> productLocations = productLocationsModel.getProductLocations();
    pm.beginTask("Reprojecting...", productLocations.size());
    for (ProductLocation productLocation : productLocations) {
        final Map<String, Product> products = productLocation.getProducts(ProgressMonitor.NULL);
        final Product crsReferenceProduct = getCrsReferenceProduct();
        for (Map.Entry<String, Product> productEntry : products.entrySet()) {
            final Product product = productEntry.getValue();
            if (!product.isCompatibleProduct(crsReferenceProduct, 0.1E-4f)) {
                Product reprojectedProduct = createProjectedProduct(product, crsReferenceProduct);
                productEntry.setValue(reprojectedProduct);
            }
        }
        pm.worked(1);
    }
    pm.done();
}
 

import com.bc.ceres.core.ProgressMonitor; //导入依赖的package包/类
@Override
public void computeTile(Band targetBand, Tile targetTile, ProgressMonitor pm) throws OperatorException {
    final GeoCoding geoCoding = sourceProduct.getSceneGeoCoding();
    final Rectangle targetRect = targetTile.getRectangle();
    final Tile altitudeTile = getAltitudeTile(targetRect, sourceProduct, useDEM);
    final Band visibilityBand = visibilityProduct.getBand(ScapeMConstants.VISIBILITY_BAND_NAME);
    final Tile visibilityTile = getSourceTile(visibilityBand, targetRect);
    final double[][] hsurfArrayCell;

    pm.beginTask("Processing frame...", targetRect.height + 1);
    try {
        if (useDEM && altitudeTile == null) {
            hsurfArrayCell = ScapeMAlgorithm.getHsurfArrayCell(targetRect, geoCoding, elevationModel, scapeMLut);
        } else {
            hsurfArrayCell = ScapeMAlgorithm.getHsurfArrayCell(targetRect, geoCoding, altitudeTile, scapeMLut);
        }

        for (int y = targetRect.y; y < targetRect.y + targetRect.height; y++) {
            for (int x = targetRect.x; x < targetRect.x + targetRect.width; x++) {
                final double visibility = visibilityTile.getSampleDouble(x, y);
                if (visibility != ScapeMConstants.VISIBILITY_NODATA_VALUE) {
                    final double aot550 = ScapeMAlgorithm.getCellAot550(visibility,
                            hsurfArrayCell[x - targetRect.x][y - targetRect.y],
                            scapeMLut);
                    targetTile.setSample(x, y, aot550);
                } else {
                    targetTile.setSample(x, y, ScapeMConstants.AOT_NODATA_VALUE);
                }
            }
            pm.worked(1);
        }
    } catch (OperatorException e) {
        // todo
        e.printStackTrace();
    } finally {
        pm.done();
    }
}