private void readBandRasterDataSubSampling(
Band sourceBand,
int sourceOffsetX,
int sourceOffsetY,
int sourceWidth,
int sourceHeight,
int sourceStepX,
int sourceStepY,
ProductData destBuffer,
int destWidth,
ProgressMonitor pm)
throws IOException {
final int sourceMinY = sourceOffsetY;
final int sourceMaxY = sourceOffsetY + sourceHeight - 1;
ProductData lineBuffer = ProductData.createInstance(destBuffer.getType(), sourceWidth);
int destPos = 0;
try {
pm.beginTask("Reading sub sampled raster data...", 2 * (sourceMaxY - sourceMinY));
for (int sourceY = sourceMinY; sourceY <= sourceMaxY; sourceY += sourceStepY) {
sourceBand.readRasterData(
sourceOffsetX, sourceY, sourceWidth, 1, lineBuffer, SubProgressMonitor.create(pm, 1));
if (sourceStepX == 1) {
copyData(lineBuffer, 0, destBuffer, destPos, destWidth);
} else {
copyLine(lineBuffer, 0, sourceWidth, sourceStepX, destBuffer, destPos);
}
pm.worked(1);
destPos += destWidth;
}
} finally {
pm.done();
}
}
public void readDescendingRasterBand(
final int sourceOffsetX,
final int sourceOffsetY,
final int sourceStepX,
final int sourceStepY,
final ProductData destBuffer,
final int destOffsetX,
final int destOffsetY,
final int destWidth,
final int destHeight,
final int imageID,
final ImageIOFile img,
final int bandSampleOffset,
final boolean isAntennaPointingRight)
throws IOException {
final Raster data;
synchronized (dataDir) {
final ImageReader reader = img.getReader();
final ImageReadParam param = reader.getDefaultReadParam();
param.setSourceSubsampling(
sourceStepX, sourceStepY, sourceOffsetX % sourceStepX, sourceOffsetY % sourceStepY);
final RenderedImage image = reader.readAsRenderedImage(0, param);
if (flipToSARGeometry && isAntennaPointingRight) { // flip the image left to right
data =
image.getData(
new Rectangle(
img.getSceneWidth() - destOffsetX - destWidth,
destOffsetY,
destWidth,
destHeight));
} else {
data = image.getData(new Rectangle(destOffsetX, destOffsetY, destWidth, destHeight));
}
}
final DataBuffer dataBuffer = data.getDataBuffer();
final SampleModel sampleModel = data.getSampleModel();
final int sampleOffset = imageID + bandSampleOffset;
if (flipToSARGeometry && isAntennaPointingRight) { // flip the image left to right
final int[] dArray = new int[destWidth * destHeight];
sampleModel.getSamples(0, 0, destWidth, destHeight, sampleOffset, dArray, dataBuffer);
int srcStride, destStride;
for (int r = 0; r < destHeight; r++) {
srcStride = r * destWidth;
destStride = r * destWidth + destWidth;
for (int c = 0; c < destWidth; c++) {
destBuffer.setElemIntAt(destStride - c - 1, dArray[srcStride + c]);
}
}
} else { // no flipping is needed
sampleModel.getSamples(
0, 0, destWidth, destHeight, sampleOffset, (int[]) destBuffer.getElems(), dataBuffer);
}
}
public DataNode(String name, ProductData data, boolean readOnly) {
super(name);
Guardian.assertNotNull("data", data);
this.dataType = data.getType();
this.numElems = data.getNumElems();
this.data = data;
this.readOnly = readOnly;
}
private static void copyData(
ProductData sourceBuffer,
int sourcePos,
ProductData destBuffer,
int destPos,
int destLength) {
System.arraycopy(
sourceBuffer.getElems(), sourcePos, destBuffer.getElems(), destPos, destLength);
}
public synchronized void readBandData(
Band destBand,
int sourceOffsetX,
int sourceOffsetY,
int sourceWidth,
int sourceHeight,
int sourceStepX,
int sourceStepY,
ProductData destBuffer,
ProgressMonitor pm)
throws IOException, InvalidRangeException {
if (mustFlipY) {
sourceOffsetY = destBand.getSceneRasterHeight() - (sourceOffsetY + sourceHeight);
}
if (mustFlipX) {
sourceOffsetX = destBand.getSceneRasterWidth() - (sourceOffsetX + sourceWidth);
}
sourceOffsetY += leadLineSkip;
start[0] = sourceOffsetY;
start[1] = sourceOffsetX;
stride[0] = sourceStepY;
stride[1] = sourceStepX;
count[0] = sourceHeight;
count[1] = sourceWidth;
Object buffer = destBuffer.getElems();
Variable variable = variableMap.get(destBand);
pm.beginTask("Reading band '" + variable.getShortName() + "'...", sourceHeight);
try {
Section section = new Section(start, count, stride);
Array array;
int[] newshape = {sourceHeight, sourceWidth};
array = variable.read(section);
if (array.getRank() == 3) {
array = array.reshapeNoCopy(newshape);
}
Object storage;
if (mustFlipX && !mustFlipY) {
storage = array.flip(1).copyTo1DJavaArray();
} else if (!mustFlipX && mustFlipY) {
storage = array.flip(0).copyTo1DJavaArray();
} else if (mustFlipX && mustFlipY) {
storage = array.flip(0).flip(1).copyTo1DJavaArray();
} else {
storage = array.copyTo1DJavaArray();
}
arraycopy(storage, 0, buffer, 0, destBuffer.getNumElems());
} finally {
pm.done();
}
}
@Test(dependsOnMethods = "checkSurchargeTest")
public void changeProductOrderDataTest() {
PartnersPages.priceManagementTab().clickOrderInformationTab();
PartnersPages.orderInformationTab().clickProductInShoppingCart(productData.getProductName());
PartnersPages.scheduleAdvancedTab().waitForProductPageLoad(productData.getProductUniqueId());
productData.setProductSize("10 columns");
productData.setProductSizeHeight("80");
Actions.advancedBookingActions().setProductData(productData);
PartnersPages.orderInformationTab().clickSaveOrderButton();
}
@Override
protected void setUp() {
_attributeInt =
new MetadataAttribute(
"attributeInt", ProductData.createInstance(ProductData.TYPE_INT32, 3), false);
_attributeFloat =
new MetadataAttribute(
"attributeFloat", ProductData.createInstance(ProductData.TYPE_FLOAT32), false);
_attributeString =
new MetadataAttribute(
"attributeString", ProductData.createInstance(ProductData.TYPE_ASCII, 32), false);
}
@Override
protected void setUp() {
_nodeList = new ProductNodeList<MetadataAttribute>();
_attribute1 =
new MetadataAttribute(
"attribute1", ProductData.createInstance(ProductData.TYPE_INT32), true);
_attribute2 =
new MetadataAttribute(
"attribute2", ProductData.createInstance(ProductData.TYPE_INT32), true);
_attribute3 =
new MetadataAttribute(
"attribute3", ProductData.createInstance(ProductData.TYPE_INT32), true);
_attribute4 =
new MetadataAttribute(
"attribute4", ProductData.createInstance(ProductData.TYPE_INT32), true);
}
private void handleMetadataGroup(Group group, MetadataElement metadataElement)
throws ProductIOException {
List<Variable> variables = group.getVariables();
for (Variable variable : variables) {
final String name = variable.getShortName();
final int dataType = getProductDataType(variable);
Array array;
try {
array = variable.read();
} catch (IOException e) {
throw new ProductIOException(e.getMessage());
}
final ProductData data = ProductData.createInstance(dataType, array.getStorage());
final MetadataAttribute attribute = new MetadataAttribute("data", data, true);
final MetadataElement sdsElement = new MetadataElement(name);
sdsElement.addAttribute(attribute);
metadataElement.addElement(sdsElement);
final List<Attribute> list = variable.getAttributes();
for (Attribute hdfAttribute : list) {
final String attribName = hdfAttribute.getShortName();
if ("units".equals(attribName)) {
attribute.setUnit(hdfAttribute.getStringValue());
} else if ("long_name".equals(attribName)) {
attribute.setDescription(hdfAttribute.getStringValue());
} else {
addAttributeToElement(sdsElement, hdfAttribute);
}
}
}
}
public void addInputParamMetadata(Product product) throws ProductIOException {
Variable inputParams = ncFile.findVariable("Input_Parameters");
if (inputParams != null) {
final MetadataElement inputParamsMeta = new MetadataElement("Input_Parameters");
Array array;
try {
array = inputParams.read();
} catch (IOException e) {
throw new ProductIOException(e.getMessage());
}
String[] lines = array.toString().split("\n");
for (String line : lines) {
String[] parts = line.split("=");
if (parts.length == 2) {
final String name = parts[0].trim();
final String value = parts[1].trim();
final ProductData data = ProductData.createInstance(ProductData.TYPE_ASCII, value);
final MetadataAttribute attribute = new MetadataAttribute(name, data, true);
inputParamsMeta.addAttribute(attribute);
}
}
final MetadataElement metadataRoot = product.getMetadataRoot();
metadataRoot.addElement(inputParamsMeta);
}
}
/**
* Releases all of the resources used by this object instance and all of its owned children. Its
* primary use is to allow the garbage collector to perform a vanilla job.
*
* <p>
*
* <p>This method should be called only if it is for sure that this object instance will never be
* used again. The results of referencing an instance of this class after a call to <code>
* dispose()</code> are undefined.
*
* <p>
*
* <p>Overrides of this method should always call <code>super.dispose();</code> after disposing
* this instance.
*/
@Override
public void dispose() {
if (data != null) {
data.dispose();
data = null;
}
super.dispose();
}
/**
* Gets the estimated size in bytes of this product node.
*
* @param subsetDef if not <code>null</code> the subset may limit the size returned
* @return the size in bytes.
*/
@Override
public long getRawStorageSize(ProductSubsetDef subsetDef) {
long size = 0L;
if (isPartOfSubset(subsetDef)) {
size += 256; // add estimated overhead of 256 bytes
size += ProductData.getElemSize(getDataType()) * getNumDataElems();
}
return size;
}
@Test(dependsOnMethods = "changeProductOrderDataTest")
public void testCheckUpdatedSurchargeTest() {
PartnersPages.orderInformationTab().clickPriceManagmentTab();
PartnersPages.priceManagementTab().waitPageToLoad();
Assert.assertEquals(
"200 In amount CHF 200.00",
PartnersPages.priceManagementTab()
.getAppliedSurchargeAmount("In color", productData.getProductName()),
"Incorrect surcharge amount");
}
public ProductData readData(Variable variable) throws ProductIOException {
final int dataType = getProductDataType(variable);
Array array;
try {
array = variable.read();
} catch (IOException e) {
throw new ProductIOException(e.getMessage());
}
return ProductData.createInstance(dataType, array.getStorage());
}
@Test(dependsOnMethods = "addProductToOrder")
public void checkSurchargeTest() {
PartnersPages.orderInformationTab().clickPriceManagmentTab();
PartnersPages.priceManagementTab().waitPageToLoad();
Assert.assertEquals(
PartnersPages.priceManagementTab()
.getAppliedSurchargeAmount("In color", productData.getProductName()),
"100 In amount CHF 100.00",
"Incorrect surcharge amount");
}
/**
* Sets the data elements of this data node.
*
* @see ProductData#setElems(Object)
*/
public void setDataElems(Object elems) {
if (isReadOnly()) {
throw new IllegalArgumentException("attribute is read-only");
}
checkState();
if (data == null) {
if (numElems > Integer.MAX_VALUE) {
throw new IllegalStateException(
"number of elements must be less than " + (long) Integer.MAX_VALUE + 1);
}
data = createCompatibleProductData((int) numElems);
}
Object oldData = data.getElems();
if (!ObjectUtils.equalObjects(oldData, elems)) {
data.setElems(elems);
fireProductNodeDataChanged();
setModified(true);
}
}
/**
* Adds a new coding value to this sample coding.
*
* @param name the coding name
* @param values the values
* @param description the description text
* @throws IllegalArgumentException if <code>name</code> is null
* @return A new attribute representing the coded sample.
*/
public MetadataAttribute addSamples(String name, int[] values, String description) {
Guardian.assertNotNull("name", name);
final ProductData productData =
ProductData.createInstance(ProductData.TYPE_INT32, values.length);
MetadataAttribute attribute = new MetadataAttribute(name, productData, false);
attribute.setDataElems(values);
if (description != null) {
attribute.setDescription(description);
}
addAttribute(attribute);
return attribute;
}
/**
* Checks if the data that should be used to access the data is compatible with the data this node
* can hold.
*
* @param data the data to be checked for compatibility
* @throws IllegalArgumentException if data is invalid.
*/
protected void checkDataCompatibility(ProductData data) throws IllegalArgumentException {
Debug.assertNotNull(data);
if (data.getType() != getDataType()) {
throw new IllegalArgumentException(
"illegal data for data node '"
+ getName()
+ "', type "
+ ProductData.getTypeString(getDataType())
+ " expected");
}
if (data.getNumElems() != getNumDataElems()) {
throw new IllegalArgumentException(
"illegal number of data elements for data node '"
+ getName()
+ "', "
+ getNumDataElems()
+ " elements expected");
}
}
public void testRsAttribute() {
try {
new MetadataAttribute(null, ProductData.createInstance(ProductData.TYPE_FLOAT32), false);
fail(
"new MetadataAttribute(null, false, Value.create(Value.TYPE_FLOAT32)) should not be possible");
} catch (IllegalArgumentException e) {
}
try {
new MetadataAttribute("a2", null, false);
fail("new MetadataAttribute(\"a2\", false, null)) should not be possible");
} catch (IllegalArgumentException e) {
}
}
MetadataAttribute attributeToMetadata(Attribute attribute) {
final int productDataType = getProductDataType(attribute.getDataType(), false, false);
if (productDataType != -1) {
ProductData productData;
if (attribute.isString()) {
productData = ProductData.createInstance(attribute.getStringValue());
} else if (attribute.isArray()) {
productData = ProductData.createInstance(productDataType, attribute.getLength());
productData.setElems(attribute.getValues().getStorage());
} else {
productData = ProductData.createInstance(productDataType, 1);
productData.setElems(attribute.getValues().getStorage());
}
return new MetadataAttribute(attribute.getShortName(), productData, true);
}
return null;
}
@Override
public synchronized void readBandData(
Band destBand,
int sourceOffsetX,
int sourceOffsetY,
int sourceWidth,
int sourceHeight,
int sourceStepX,
int sourceStepY,
ProductData destBuffer,
ProgressMonitor pm)
throws IOException, InvalidRangeException {
final Variable variable = variableMap.get(destBand);
DataType prodtype = variable.getDataType();
float[] fbuffer;
short[] sbuffer;
int[] ibuffer;
byte[] bbuffer;
Object buffer;
if (prodtype == DataType.FLOAT) {
fbuffer = (float[]) destBuffer.getElems();
Arrays.fill(fbuffer, Float.NaN);
buffer = fbuffer;
} else if (prodtype == DataType.SHORT) {
sbuffer = (short[]) destBuffer.getElems();
Arrays.fill(sbuffer, (short) -999);
buffer = sbuffer;
} else if (prodtype == DataType.BYTE) {
bbuffer = (byte[]) destBuffer.getElems();
Arrays.fill(bbuffer, (byte) 255);
buffer = bbuffer;
} else {
ibuffer = (int[]) destBuffer.getElems();
Arrays.fill(ibuffer, -999);
buffer = ibuffer;
}
if (rowInfo == null) {
rowInfo = createRowInfos();
}
final int height = sceneHeight;
final int width = sceneWidth;
final ISINGrid grid = this.grid;
// loop over lines
try {
int[] lineOffsets = new int[1];
int[] lineLengths = new int[1];
int[] stride = new int[1];
stride[0] = 1;
// for (int y = sourceOffsetY; y < sourceOffsetY + sourceHeight; y++) {
for (int y = sourceOffsetY; y < sourceOffsetY + sourceHeight; y += sourceStepY) {
if (pm.isCanceled()) {
break;
}
final int rowIndex = (height - 1) - y;
final RowInfo rowInfo = this.rowInfo[rowIndex];
if (rowInfo != null) {
final int lineOffset = rowInfo.offset;
final int lineLength = rowInfo.length;
lineOffsets[0] = lineOffset;
lineLengths[0] = lineLength;
final Object bindata;
synchronized (ncFile) {
bindata = variable.read().section(lineOffsets, lineLengths, stride).copyTo1DJavaArray();
}
int lineIndex0 = 0;
for (int x = sourceOffsetX; x < sourceOffsetX + sourceWidth; x++) {
final double lon = x * 360.0 / width;
final int binIndex = grid.getBinIndex(rowIndex, lon);
int lineIndex = -1;
for (int i = lineIndex0; i < lineLength; i++) {
int binidx = bins[lineOffset + i];
if (binidx >= binIndex) {
if (binidx == binIndex) {
lineIndex = i;
}
lineIndex0 = i;
break;
}
}
if (lineIndex >= 0) {
final int rasterIndex = sourceWidth * (y - sourceOffsetY) + (x - sourceOffsetX);
System.arraycopy(bindata, lineIndex, buffer, rasterIndex, 1);
}
}
pm.worked(1);
}
}
} finally {
pm.done();
}
}
// Don't do this...it hurts. Too much of a memory hog...
private void addBandsBinMap(Product product) throws IOException, InvalidRangeException {
String[] bandList = product.getBandNames();
if (rowInfo == null) {
rowInfo = createRowInfos();
}
final int height = sceneHeight;
final int width = sceneWidth;
final ISINGrid grid = this.grid;
// loop over lines
try {
int[] lineOffsets = new int[1];
int[] lineLengths = new int[1];
int[] stride = new int[1];
stride[0] = 1;
// for (int y = sourceOffsetY; y < sourceOffsetY + sourceHeight; y++) {
for (String name : bandList) {
if (name.endsWith("mean") || name.endsWith("stdev")) continue;
Band band = product.getBand(name);
ProductData buffer;
final Variable variable = variableMap.get(band);
DataType prodtype = variable.getDataType();
float[] fbuffer = new float[width * height];
short[] sbuffer = new short[width * height];
int[] ibuffer = new int[width * height];
byte[] bbuffer = new byte[width * height];
if (prodtype == DataType.FLOAT) {
Arrays.fill(fbuffer, Float.NaN);
buffer = ProductData.createInstance(fbuffer);
} else if (prodtype == DataType.SHORT) {
Arrays.fill(sbuffer, (short) -999);
buffer = ProductData.createInstance(sbuffer);
} else if (prodtype == DataType.BYTE) {
Arrays.fill(bbuffer, (byte) 255);
buffer = ProductData.createInstance(bbuffer);
} else {
Arrays.fill(ibuffer, -999);
buffer = ProductData.createInstance(ibuffer);
}
for (int y = 0; y < height; y++) {
final int rowIndex = (height - 1) - y;
final RowInfo rowInfo = this.rowInfo[rowIndex];
if (rowInfo != null) {
final Array bindata;
final int lineOffset = rowInfo.offset;
final int lineLength = rowInfo.length;
lineOffsets[0] = lineOffset;
lineLengths[0] = lineLength;
synchronized (ncFile) {
bindata =
variable
.read()
.section(lineOffsets, lineLengths, stride); // .copyTo1DJavaArray();
}
int lineIndex0 = 0;
for (int x = 0; x < width; x++) {
final double lon = x * 360.0 / width;
final int binIndex = grid.getBinIndex(rowIndex, lon);
int lineIndex = -1;
for (int i = lineIndex0; i < lineLength; i++) {
int binidx = bins[lineOffset + i];
if (binidx >= binIndex) {
if (binidx == binIndex) {
lineIndex = i;
}
lineIndex0 = i;
break;
}
}
if (lineIndex >= 0) {
final int rasterIndex = width * y + x;
final Array elem;
elem = Array.factory(bindata.copyTo1DJavaArray());
for (int i = 0; i < elem.getSize(); i++) {
if (prodtype == DataType.FLOAT) {
buffer.setElemFloatAt(rasterIndex, elem.getFloat(i));
} else {
buffer.setElemIntAt(rasterIndex, elem.getInt(i));
}
// System.arraycopy(bindata, lineIndex, buffer,
// rasterIndex, 1);
}
}
}
}
}
band.setDataElems(buffer);
}
} catch (IOException e) {
throw new IOException("Could not map product " + product.getName(), e);
}
}
private void checkBufferSize(int sourceWidth, int sourceHeight, ProductData sourceBuffer) {
int expectedBufferSize = sourceWidth * sourceHeight;
int actualBufferSize = sourceBuffer.getNumElems();
Guardian.assertEquals("wrong sourceBuffer size", actualBufferSize, expectedBufferSize);
}
/** {@inheritDoc} */
public void writeBandRasterData(
Band sourceBand,
int sourceOffsetX,
int sourceOffsetY,
int sourceWidth,
int sourceHeight,
ProductData sourceBuffer,
ProgressMonitor pm)
throws IOException {
checkBufferSize(sourceWidth, sourceHeight, sourceBuffer);
final int sourceBandWidth = sourceBand.getSceneRasterWidth();
final int sourceBandHeight = sourceBand.getSceneRasterHeight();
checkSourceRegionInsideBandRegion(
sourceWidth, sourceBandWidth, sourceHeight, sourceBandHeight, sourceOffsetX, sourceOffsetY);
int memTypeID = -1;
int memSpaceID = -1;
pm.beginTask("Writing band '" + sourceBand.getName() + "'...", 1);
try {
final int datasetID = getOrCreateBandH5D(sourceBand);
final int fileSpaceID = H5.H5Dget_space(datasetID);
final long[] memDims = new long[] {sourceHeight, sourceWidth};
final long[] memStart = new long[2];
final long[] memCount = new long[2];
final long[] fileStart = new long[2];
final long[] fileCount = new long[2];
memTypeID = createH5TypeID(sourceBuffer.getType());
memSpaceID = H5.H5Screate_simple(2, memDims, null);
memStart[0] = 0;
memStart[1] = 0;
memCount[0] = sourceHeight;
memCount[1] = sourceWidth;
H5.H5Sselect_hyperslab(
memSpaceID, HDF5Constants.H5S_SELECT_SET, memStart, null, memCount, null);
fileStart[0] = sourceOffsetY;
fileStart[1] = sourceOffsetX;
fileCount[0] = sourceHeight;
fileCount[1] = sourceWidth;
H5.H5Sselect_hyperslab(
fileSpaceID, HDF5Constants.H5S_SELECT_SET, fileStart, null, fileCount, null);
H5.H5Dwrite(
datasetID,
memTypeID,
memSpaceID,
fileSpaceID,
HDF5Constants.H5P_DEFAULT,
sourceBuffer.getElems());
pm.worked(1);
} catch (IOException e) {
throw e;
} catch (HDF5Exception e) {
throw new ProductIOException(createErrorMessage(e));
} finally {
closeH5S(memSpaceID);
closeH5T(memTypeID);
pm.done();
}
}
/**
* Creates product data that is compatible to this dataset's data type. The data buffer returned
* contains exactly <code>numElems</code> elements of a compatible data type.
*
* @param numElems the number of elements, must not be less than one
* @return product data compatible with this data node
*/
public ProductData createCompatibleProductData(final int numElems) {
return ProductData.createInstance(getDataType(), numElems);
}
/**
* Tests whether the data type of this node is a floating point type.
*
* @return true, if so
*/
public boolean isFloatingPointType() {
return ProductData.isFloatingPointType(dataType);
}
private static void copyLine(
ProductData sourceBuffer,
int sourceOffsetPos,
int sourceWidth,
int sourceStepX,
ProductData destBuffer,
int destOffsetPos) {
final int sourceMinX = sourceOffsetPos;
final int sourceMaxX = sourceOffsetPos + sourceWidth - 1;
if (destBuffer.getElems() instanceof byte[]) {
byte[] destArray = (byte[]) destBuffer.getElems();
byte[] sourceArray = (byte[]) sourceBuffer.getElems();
for (int sourceX = sourceMinX; sourceX <= sourceMaxX; sourceX += sourceStepX) {
destArray[destOffsetPos] = sourceArray[sourceX];
destOffsetPos++;
}
} else if (destBuffer.getElems() instanceof short[]) {
short[] destArray = (short[]) destBuffer.getElems();
short[] sourceArray = (short[]) sourceBuffer.getElems();
for (int sourceX = sourceMinX; sourceX <= sourceMaxX; sourceX += sourceStepX) {
destArray[destOffsetPos] = sourceArray[sourceX];
destOffsetPos++;
}
} else if (destBuffer.getElems() instanceof int[]) {
int[] destArray = (int[]) destBuffer.getElems();
int[] sourceArray = (int[]) sourceBuffer.getElems();
for (int sourceX = sourceMinX; sourceX <= sourceMaxX; sourceX += sourceStepX) {
destArray[destOffsetPos] = sourceArray[sourceX];
destOffsetPos++;
}
} else if (destBuffer.getElems() instanceof float[]) {
float[] destArray = (float[]) destBuffer.getElems();
float[] sourceArray = (float[]) sourceBuffer.getElems();
for (int sourceX = sourceMinX; sourceX <= sourceMaxX; sourceX += sourceStepX) {
destArray[destOffsetPos] = sourceArray[sourceX];
destOffsetPos++;
}
} else if (destBuffer.getElems() instanceof double[]) {
double[] destArray = (double[]) destBuffer.getElems();
double[] sourceArray = (double[]) sourceBuffer.getElems();
for (int sourceX = sourceMinX; sourceX <= sourceMaxX; sourceX += sourceStepX) {
destArray[destOffsetPos] = sourceArray[sourceX];
destOffsetPos++;
}
} else {
Debug.assertTrue(false, "illegal product data type");
throw new IllegalStateException("illegal product data type");
}
}
@Test(dependsOnMethods = "selectCustomerTest")
public void addProductToOrder() {
productData = new ProductData();
productData.setProductName("Il Mattino della Domenica");
productData.setProductUniqueId("24206");
productData.setProductAdType("Ads");
productData.setProductHeading("Recommendations");
productData.setProductSubHeading("Base");
productData.setProductColor("B/W + 3 colors");
productData.setProductPrescriptionSize("Full material");
productData.setProductSize("2 columns");
productData.setProductSizeHeight("50");
productData.setProductDatesCount(1);
productData.setProductContentType("07 Without digital transmission");
productData.setProductContentDescription("Description");
Actions.advancedBookingActions().addProductToShoppingCart(productData);
PartnersPages.orderInformationTab().clickSaveOrderButton();
}
/**
* Gets the data element size in bytes.
*
* @see ProductData#getElemSize(int)
*/
public int getDataElemSize() {
return ProductData.getElemSize(getDataType());
}
