Best Java code snippets using org.esa.snap.core.datamodel.ProductNodeGroup.get (Showing top 20 results out of 315)

@Override
boolean isDirectChild(ProductNode productNode) {
  int nodeCount = group.getNodeCount();
  for (int i = 0; i < nodeCount; i++) {
    if (group.get(i) == productNode) {
      return true;
    }
  }
  return false;
}

private static boolean productContainsMasks(Product sourceProduct) {
  for(int k = 0; k < ForestCoverChangeConstants.SENTINEL_MASK_NAMES.length; k++) {
    Mask sourceMask = sourceProduct.getMaskGroup().get(ForestCoverChangeConstants.SENTINEL_MASK_NAMES[k]);
    if(sourceMask == null) {
      return false;
    }
  }
  return true;
}

private void ensureMaskVisible(ProductSceneView view) {
  Product product = view.getProduct();
  ProductNodeGroup<Mask> overlayMaskGroup = view.getRaster().getOverlayMaskGroup();
  Mask mask = overlayMaskGroup.getByDisplayName(MagicWandModel.MAGIC_WAND_MASK_NAME);
  if (mask == null) {
    mask = product.getMaskGroup().get(MagicWandModel.MAGIC_WAND_MASK_NAME);
    if (mask != null) {
      overlayMaskGroup.add(mask);
    }
  }
}

public WarpData(ProductNodeGroup<Placemark> slaveGCPGroup) {
  for (int i = 0; i < slaveGCPGroup.getNodeCount(); ++i) {
    slaveGCPList.add(slaveGCPGroup.get(i));
  }
}

Mask getMask(int selectedRow) {
  ProductNodeGroup<Mask> maskGroup = getMaskGroup();
  return maskGroup.get(selectedRow);
}

@Override
protected boolean createKeys(List<T> list) {
  int nodeCount = group.getNodeCount();
  for (int i = 0; i < nodeCount; i++) {
    list.add(group.get(i));
  }
  return true;
}

private boolean checkGCPValidity(final PixelPos pixelPos) {
  boolean valid = (pixelPos.x - cHalfWindowWidth + 1 >= 0 && pixelPos.x + cHalfWindowWidth <= sourceImageWidth - 1) &&
      (pixelPos.y - cHalfWindowHeight + 1 >= 0 && pixelPos.y + cHalfWindowHeight <= sourceImageHeight - 1);
  if (valid && roiVector != null && !roiVector.isEmpty()) {
    Mask mask = sourceProduct.getMaskGroup().get(roiVector);
    valid = mask.getSampleInt((int) pixelPos.x, (int) pixelPos.y) != 0;
  }
  return valid;
}

private void copyIndexCoding() {
  final ProductNodeGroup<IndexCoding> indexCodingGroup = sourceProduct.getIndexCodingGroup();
  for (int i = 0; i < indexCodingGroup.getNodeCount(); i++) {
    IndexCoding sourceIndexCoding = indexCodingGroup.get(i);
    ProductUtils.copyIndexCoding(sourceIndexCoding, targetProduct);
  }
}

  @Override
  protected boolean isValidMaskPixel(int x, int y) {
    boolean isValidMaskPixel = false;
    for (int k=0; k<this.maskNamesToCombine.length && !isValidMaskPixel; k++) {
      Mask sourceMask = this.product.getMaskGroup().get(this.maskNamesToCombine[k]);
      if (sourceMask.getSampleInt(x, y) != ForestCoverChangeConstants.NO_DATA_VALUE) {
        isValidMaskPixel = true;
      }
    }

    return isValidMaskPixel;
  }
}

private Placemark getPlacemarkAt(final int selectedRow) {
  Placemark placemark = null;
  if (product != null) {
    if (selectedRow > -1 && selectedRow < getPlacemarkGroup(product).getNodeCount()) {
      placemark = getPlacemarkGroup(product).get(selectedRow);
    }
  }
  return placemark;
}

private static void reprojectBandData(Mask[] selectedMasks, Product sourceProduct, Product targetProduct) {
  final Map<String, Object> projParameters = Collections.emptyMap();
  Map<String, Product> projProducts = new HashMap<>();
  projProducts.put("source", sourceProduct);
  projProducts.put("collocateWith", targetProduct);
  Product reprojectedProduct = GPF.createProduct("Reproject", projParameters, projProducts);
  for (Mask mask : selectedMasks) {
    Band band = createBandCopy(targetProduct, mask);
    MultiLevelImage image = reprojectedProduct.getMaskGroup().get(mask.getName()).getSourceImage();
    band.setSourceImage(image);
  }
}

private static Placemark[] getValidGcps(ProductNodeGroup<Placemark> gcpGroup) {
  final List<Placemark> gcpList = new ArrayList<Placemark>(gcpGroup.getNodeCount());
  for (int i = 0; i < gcpGroup.getNodeCount(); i++) {
    final Placemark p = gcpGroup.get(i);
    final PixelPos pixelPos = p.getPixelPos();
    final GeoPos geoPos = p.getGeoPos();
    if (pixelPos != null && pixelPos.isValid() && geoPos != null && geoPos.isValid()) {
      gcpList.add(p);
    }
  }
  return gcpList.toArray(new Placemark[gcpList.size()]);
}

@Override
public Layer createLayer(LayerContext ctx, PropertySet configuration) {
  Assert.notNull(ctx, "ctx");
  final ProductLayerContext plc = (ProductLayerContext) ctx;
  final String vectorDataName = (String) configuration.getValue(PROPERTY_NAME_VECTOR_DATA);
  final VectorDataNode vectorDataNode = plc.getProduct().getVectorDataGroup().get(vectorDataName);
  Assert.notNull(vectorDataNode, String.format("VectorDataNode '%s' does not exist", vectorDataName));
  final ProductNode productNode = plc.getProductNode();
  assert(productNode instanceof RasterDataNode);
  return createLayer(vectorDataNode, (RasterDataNode) productNode, configuration);
}

private boolean allOffsetsAreEqual(ProductNodeGroup productNodeGroup, double xOffset, double yOffset) {
  for (int i = 0; i < productNodeGroup.getNodeCount(); i++) {
    final double nodeXOffset = ((RasterDataNode) productNodeGroup.get(i)).getImageToModelTransform().getTranslateX();
    final double nodeYOffset = ((RasterDataNode) productNodeGroup.get(i)).getImageToModelTransform().getTranslateY();
    if (Math.abs(nodeXOffset - xOffset) > 1e-8 || Math.abs(nodeYOffset - yOffset) > 1e-8) {
      return false;
    }
  }
  return true;
}

  @Override
  public void actionPerformed(ActionEvent e) {
    if (plotAreaSelectionTool != null) {
      plotAreaSelectionTool.removeAnnotation();
    }
    Product product = pagePanel.getProduct();
    if (product != null) {
      Mask mask = product.getMaskGroup().get(maskName);
      if (mask != null) {
        product.getMaskGroup().remove(mask);
      }
    }
  }
});

private boolean allOffsetsAreEqual(ProductNodeGroup productNodeGroup, double xOffset, double yOffset) {
  for (int i = 0; i < productNodeGroup.getNodeCount(); i++) {
    final double nodeXOffset = ((RasterDataNode) productNodeGroup.get(i)).getImageToModelTransform().getTranslateX();
    final double nodeYOffset = ((RasterDataNode) productNodeGroup.get(i)).getImageToModelTransform().getTranslateY();
    if (Math.abs(nodeXOffset - xOffset) > 1e-8 || Math.abs(nodeYOffset - yOffset) > 1e-8) {
      return false;
    }
  }
  return true;
}

DefaultReprojectionSettingsProvider(ImageGeometry imageGeometry) {
  Band firstBand = sourceProduct.getBandGroup().get(0);
  MultiLevelModel sourceModel = firstBand.getMultiLevelModel();
  MultiLevelModel targetModel = targetProduct.createMultiLevelModel();
  Reproject reprojection = new Reproject(targetModel.getLevelCount());
  defaultReprojectionSettings = new ReprojectionSettings(null, sourceModel, imageGeometry);
  defaultReprojectionSettings.setTargetModel(targetModel);
  defaultReprojectionSettings.setReprojection(reprojection);
}

private static void addMaskNameRefs(Product product, String namePrefix, List<String> list) {
  for (int j = 0; j < product.getMaskGroup().getNodeCount(); j++) {
    Mask mask = product.getMaskGroup().get(j);
    list.add(namePrefix + mask.getName());
  }
}

private synchronized void addProduct(final Product product) {
  productSet.add(product);
  for(int i=0; i < product.getQuicklookGroup().getNodeCount(); ++i) {
    quicklookNameSet.add(product.getQuicklookGroup().get(i).getName());
  }
  updateQuicklookNameCombo();
}

/**
 * Copy GCPs of the first target band to current target band.
 *
 * @param firstTargetBand First target band.
 * @param targetBand      Current target band.
 */
private static void copyFirstTargetBandGCPs(final Band firstTargetBand, final Band targetBand) {
  final ProductNodeGroup<Placemark> firstTargetBandGcpGroup = GCPManager.instance().getGcpGroup(firstTargetBand);
  final ProductNodeGroup<Placemark> currentTargetBandGCPGroup = GCPManager.instance().getGcpGroup(targetBand);
  final int numberOfGCPs = firstTargetBandGcpGroup.getNodeCount();
  for (int i = 0; i < numberOfGCPs; ++i) {
    currentTargetBandGCPGroup.add(firstTargetBandGcpGroup.get(i));
  }
}