public static GridCoverage2D removeNovalues(GridCoverage2D geodata) {
// need to adapt it, for now do it dirty
HashMap<String, Double> params = getRegionParamsFromGridCoverage(geodata);
int height = params.get(ROWS).intValue();
int width = params.get(COLS).intValue();
WritableRaster tmpWR = createDoubleWritableRaster(width, height, null, null, null);
WritableRandomIter tmpIter = RandomIterFactory.createWritable(tmpWR, null);
RenderedImage readRI = geodata.getRenderedImage();
RandomIter readIter = RandomIterFactory.create(readRI, null);
for (int r = 0; r < height; r++) {
for (int c = 0; c < width; c++) {
double value = readIter.getSampleDouble(c, r, 0);
if (Double.isNaN(value)
|| Float.isNaN((float) value)
|| Math.abs(value - -9999.0) < .0000001) {
tmpIter.setSample(c, r, 0, Double.NaN);
} else {
tmpIter.setSample(c, r, 0, value);
}
}
}
geodata = buildCoverage("newcoverage", tmpWR, params, geodata.getCoordinateReferenceSystem());
return geodata;
}
/**
* This method will be called when the mouse is clicked over the image being displayed. The
* coordinates and pixel value will be stored on an ArrayList.
*
* @param me the mouse event that caused the execution of this method.
*/
public void mouseClicked(MouseEvent me) {
int x = me.getX();
int y = me.getY();
System.out.println("Storing " + x + "," + y);
if ((x >= width) || (y >= height)) {
clicksInformation.add("No data!");
return;
}
if (isDoubleType) // process the pixel as an array of double values
{
StringBuffer coords = new StringBuffer();
coords.append(x + "," + y + " [");
readIterator.getPixel(x, y, dpixel); // read the pixel
for (int b = 0; b < dpixel.length; b++)
coords.append(dpixel[b] + ","); // append to the StringBuffer
coords.deleteCharAt(coords.length() - 1); // erase last comma
coords.append("]");
// Put the formatted StringBuffer on the
clicksInformation.add(coords.toString());
} else // pixel type is not floating point, will be processed as integers.
{
if (isIndexed) // if color model is indexed
{
StringBuffer coords = new StringBuffer();
coords.append(x + "," + y + " ");
readIterator.getPixel(x, y, ipixel); // read the pixel
// Assume ipixel.length = 1
coords.append("Index: " + ipixel[0] + " [");
// Add also the RGB entry from the LUT.
coords.append(
" RGB:"
+ lutData[0][ipixel[0]]
+ ","
+ lutData[1][ipixel[0]]
+ ","
+ lutData[2][ipixel[0]]);
coords.append("]");
// Put the formatted StringBuffer on the
clicksInformation.add(coords.toString());
} else // pixels are of integer type, but not indexed
{
StringBuffer coords = new StringBuffer();
coords.append(x + "," + y + " [");
readIterator.getPixel(x, y, ipixel); // read the pixel
for (int b = 0; b < ipixel.length; b++)
coords.append(ipixel[b] + ","); // append to the StringBuffer
coords.deleteCharAt(coords.length() - 1); // erase last comma
coords.append("]");
// Put the formatted StringBuffer on the
clicksInformation.add(coords.toString());
}
} // pixel is integer type
} // end of method mouseClicked
/*
* This method averages the pixel values around a central point and return the
* average as an instance of Color. The point coordinates are proportional to
* the image.
*/
private Color averageAround(BufferedImage i, double px, double py) {
// Get an iterator for the image.
RandomIter iterator = RandomIterFactory.create(i, null);
// Get memory for a pixel and for the accumulator.
double[] pixel = new double[i.getSampleModel().getNumBands()];
double[] accum = new double[3];
int numPixels = 0;
// Sample the pixels.
for (double x = px * i.getWidth() - sampleSize; x < px * i.getWidth() + sampleSize; x++) {
for (double y = py * i.getHeight() - sampleSize; y < py * i.getHeight() + sampleSize; y++) {
iterator.getPixel((int) x, (int) y, pixel);
accum[0] += pixel[0];
accum[1] += pixel[1];
accum[2] += pixel[2];
numPixels++;
}
}
// Average the accumulated values.
accum[0] /= numPixels;
accum[1] /= numPixels;
accum[2] /= numPixels;
return new Color((int) accum[0], (int) accum[1], (int) accum[2]);
}
public double[] findNeighPixel(
PlanarImage im,
int x,
int y,
int width,
int height,
SampleModel sm,
int nbands,
RandomIter iterator) {
double[] SumPixels = new double[nbands];
double[] pixel = new double[nbands];
int numPointsUsed = 0;
int numNeighborsToConsider = 30;
for (int h = Math.max(y - numNeighborsToConsider, 0);
h < Math.min(y + numNeighborsToConsider, height);
h++) {
for (int w = Math.max(x - numNeighborsToConsider, 0);
w < Math.min(x + numNeighborsToConsider, width);
w++) {
// Get the array of values for the pixel on the w,h coordinate.
iterator.getPixel(w, h, pixel);
// Add the values.
if (!isWhite(pixel) && !isBlack(pixel)) {
for (int i = 0; i < nbands; i++) {
SumPixels[i] += pixel[i];
}
numPointsUsed++;
}
}
}
if (numPointsUsed > 0) {
for (int i = 0; i < nbands; i++) {
pixel[i] = SumPixels[i] / numPointsUsed;
}
} else {
pixel = new double[] {0, 0, 0};
}
return pixel;
}
// This method is similar to the testBandMerge method but it tests the ExtendedBandMergeOpImage
// class
private void testExtendedBandMerge(RenderedImage[] sources, boolean noDataUsed, boolean roiUsed) {
// Optional No Data Range used
Range[] noData;
// Source image data type
int dataType = sources[0].getSampleModel().getDataType();
// If no Data are present, the No Data Range associated is used
if (noDataUsed) {
switch (dataType) {
case DataBuffer.TYPE_BYTE:
noData = noDataByte;
break;
case DataBuffer.TYPE_USHORT:
noData = noDataUShort;
break;
case DataBuffer.TYPE_SHORT:
noData = noDataShort;
break;
case DataBuffer.TYPE_INT:
noData = noDataInt;
break;
case DataBuffer.TYPE_FLOAT:
noData = noDataFloat;
break;
case DataBuffer.TYPE_DOUBLE:
noData = noDataDouble;
break;
default:
throw new IllegalArgumentException("Wrong data type");
}
} else {
noData = null;
}
// ROI to use
ROI roi = null;
if (roiUsed) {
roi = roiData;
}
// New array ofr the transformed source images
RenderedOp[] translated = new RenderedOp[sources.length];
List<AffineTransform> transform = new ArrayList<AffineTransform>();
for (int i = 0; i < sources.length; i++) {
// Translation coefficients
int xTrans = (int) (Math.random() * 10);
int yTrans = (int) (Math.random() * 10);
// Translation operation
AffineTransform tr = AffineTransform.getTranslateInstance(xTrans, yTrans);
// Addition to the transformations list
transform.add(tr);
// Translation of the image
translated[i] =
TranslateDescriptor.create(sources[i], (float) xTrans, (float) yTrans, null, null);
}
// Definition of the final image dimensions
ImageLayout layout = new ImageLayout();
layout.setMinX(sources[0].getMinX());
layout.setMinY(sources[0].getMinY());
layout.setWidth(sources[0].getWidth());
layout.setHeight(sources[0].getHeight());
RenderingHints hints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);
// BandMerge operation
RenderedOp merged =
BandMergeDescriptor.create(noData, destNoData, hints, transform, roi, translated);
Assert.assertNotNull(merged.getTiles());
// Check if the bands number is the same
assertEquals(BAND_NUMBER, merged.getNumBands());
// Upper-Left tile indexes
int minTileX = merged.getMinTileX();
int minTileY = merged.getMinTileY();
// Raster object
Raster upperLeftTile = merged.getTile(minTileX, minTileY);
// Tile bounds
int minX = upperLeftTile.getMinX();
int minY = upperLeftTile.getMinY();
int maxX = upperLeftTile.getWidth() + minX;
int maxY = upperLeftTile.getHeight() + minY;
// Source corners
final int dstMinX = merged.getMinX();
final int dstMinY = merged.getMinY();
final int dstMaxX = merged.getMaxX();
final int dstMaxY = merged.getMaxY();
Point2D ptDst = new Point2D.Double(0, 0);
Point2D ptSrc = new Point2D.Double(0, 0);
// Cycle on all the tile Bands
for (int b = 0; b < BAND_NUMBER; b++) {
RandomIter iter = RandomIterFactory.create(translated[b], null);
// Source corners
final int srcMinX = translated[b].getMinX();
final int srcMinY = translated[b].getMinY();
final int srcMaxX = translated[b].getMaxX();
final int srcMaxY = translated[b].getMaxY();
// Cycle on the y-axis
for (int x = minX; x < maxX; x++) {
// Cycle on the x-axis
for (int y = minY; y < maxY; y++) {
// Calculated value
double value = upperLeftTile.getSampleDouble(x, y, b);
// If the tile pixels are outside the image bounds, then no data is set.
if (x < dstMinX || x >= dstMaxX || y < dstMinY || y >= dstMaxY) {
value = destNoData;
}
// Set the x,y destination pixel location
ptDst.setLocation(x, y);
// Map destination pixel to source pixel
transform.get(b).transform(ptDst, ptSrc);
// Source pixel indexes
int srcX = round(ptSrc.getX());
int srcY = round(ptSrc.getY());
double valueOld = destNoData;
// Check if the pixel is inside the source bounds
if (!(srcX < srcMinX || srcX >= srcMaxX || srcY < srcMinY || srcY >= srcMaxY)) {
// Old band value
valueOld = iter.getSampleDouble(srcX, srcY, 0);
}
// ROI CHECK
boolean contained = true;
if (roiUsed) {
if (!roi.contains(x, y)) {
contained = false;
// Comparison if the final value is not inside a ROI
assertEquals(value, destNoData, TOLERANCE);
}
}
if (contained) {
// If no Data are present, no data check is performed
if (noDataUsed) {
switch (dataType) {
case DataBuffer.TYPE_BYTE:
byte sampleB = ImageUtil.clampRoundByte(value);
byte sampleBOld = ImageUtil.clampRoundByte(valueOld);
if (noData[0].contains(sampleBOld)) {
assertEquals(sampleB, destNoData, TOLERANCE);
} else {
assertEquals(sampleB, valueOld, TOLERANCE);
}
break;
case DataBuffer.TYPE_USHORT:
short sampleUS = ImageUtil.clampRoundUShort(value);
short sampleUSOld = ImageUtil.clampRoundUShort(valueOld);
if (noData[0].contains(sampleUSOld)) {
assertEquals(sampleUS, destNoData, TOLERANCE);
} else {
assertEquals(sampleUS, valueOld, TOLERANCE);
}
break;
case DataBuffer.TYPE_SHORT:
short sampleS = ImageUtil.clampRoundShort(value);
short sampleSOld = ImageUtil.clampRoundShort(valueOld);
if (noData[0].contains(sampleSOld)) {
assertEquals(sampleS, destNoData, TOLERANCE);
} else {
assertEquals(sampleS, valueOld, TOLERANCE);
}
break;
case DataBuffer.TYPE_INT:
int sampleI = ImageUtil.clampRoundInt(value);
int sampleIOld = ImageUtil.clampRoundInt(valueOld);
if (noData[0].contains(sampleIOld)) {
assertEquals(sampleI, destNoData, TOLERANCE);
} else {
assertEquals(sampleI, valueOld, TOLERANCE);
}
break;
case DataBuffer.TYPE_FLOAT:
float sampleF = ImageUtil.clampFloat(value);
float sampleFOld = ImageUtil.clampFloat(valueOld);
if (noData[0].contains(sampleFOld)) {
assertEquals(sampleF, destNoData, TOLERANCE);
} else {
assertEquals(sampleF, valueOld, TOLERANCE);
}
break;
case DataBuffer.TYPE_DOUBLE:
if (noData[0].contains(valueOld)) {
assertEquals(value, destNoData, TOLERANCE);
} else {
assertEquals(value, valueOld, TOLERANCE);
}
break;
default:
throw new IllegalArgumentException("Wrong data type");
}
} else {
// Else a simple value comparison is done
assertEquals(value, valueOld, TOLERANCE);
}
}
}
}
}
// Disposal of the output image
merged.dispose();
}
/**
* Checking if NoData and ROI are defined correctly
*
* @param indexed
* @param image
* @param roi
* @param nodata
* @param destNoData
*/
private void checkNoDataROI(
RenderedImage indexed, RenderedImage image, ROI roi, Range nodata, int destNoData) {
// Ensure the dimensions are the same
assertEquals(indexed.getMinX(), image.getMinX());
assertEquals(indexed.getMinY(), image.getMinY());
assertEquals(indexed.getWidth(), image.getWidth());
assertEquals(indexed.getHeight(), image.getHeight());
boolean roiExists = roi != null;
boolean nodataExists = nodata != null;
// Simply ensure no exception is thrown
if (!nodataExists && !roiExists) {
PlanarImage.wrapRenderedImage(indexed).getTiles();
return;
}
if (nodataExists) {
nodata = RangeFactory.convertToDoubleRange(nodata);
}
RandomIter roiIter = null;
Rectangle roiBounds = null;
if (roiExists) {
PlanarImage roiIMG = roi.getAsImage();
roiIter = RandomIterFactory.create(roiIMG, null, true, true);
roiBounds = roi.getBounds();
}
// Else check ROI and NoData
RandomIter sourceIter = RandomIterFactory.create(image, null, true, true);
RandomIter destIter = RandomIterFactory.create(indexed, null, true, true);
// Start the iteration (we iterate only the first band)
int w = image.getWidth();
int h = image.getHeight();
int minX = image.getMinX();
int minY = image.getMinY();
int maxX = minX + w;
int maxY = minY + h;
int limx = minX - image.getTileGridXOffset();
int limy = minY - image.getTileGridYOffset();
Rectangle translated = new Rectangle(limx, limy, w, h);
for (int y = minY; y < maxY; y++) {
for (int x = minX; x < maxX; x++) {
double src = sourceIter.getSampleDouble(x, y, 0);
double dest = destIter.getSampleDouble(x, y, 0);
boolean valid = true;
// ROI Check
if (roiExists
&& !(roiBounds.contains(x, y) && roiIter.getSample(x, y, 0) > 0)
&& translated.contains(x, y)) {
valid = false;
}
// NoData Check
if (nodataExists && nodata.contains(src)) {
valid = false;
}
if (!valid) {
assertEquals(destNoData, dest, TOLERANCE);
}
}
}
}
public double[][] PlanarImage2DataGrid(PlanarImage img, String EmageType) {
double[][] BucketArray = new double[img.getHeight()][img.getWidth()];
int width = img.getWidth();
int height = img.getHeight();
// Get the number of bands on the image.
SampleModel sm = img.getSampleModel();
int nbands = sm.getNumBands();
// We assume that we can get the pixels values in a integer array.
double[] pixel = new double[nbands];
// Get an iterator for the image.
RandomIter iterator = RandomIterFactory.create(img, null);
if (ignoreColorSamplesBeyond > -1) {
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
iterator.getPixel(i, j, pixel);
double curDiff = 999999999;
double diff = 0;
int curBucket = -1;
for (int i2 = 0; i2 < colorMatrix.length; i2++) {
for (int j2 = 0; j2 < Math.min(nbands, colorMatrix[0].length); j2++) {
diff += (pixel[j2] - colorMatrix[i2][j2]) * (pixel[j2] - colorMatrix[i2][j2]);
}
if (diff < curDiff) {
curDiff = diff;
curBucket = i2;
}
// log.info("i: " + i2 + ", val: " + diff);
diff = 0;
}
if (curBucket >= ignoreColorSamplesBeyond) curBucket = -1;
BucketArray[j][i] =
(curBucket
+ 1); // *255 / (colorMatrix.length); actually show the categories not normalized
// to 255 now.
// if(curBucket >= 0) log.info(curBucket + "," + BucketArray[j][i]);
}
}
} else {
log.info("Ignoring any binning. Going with gray values");
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
int sumChannels = 0;
iterator.getPixel(j, i, pixel);
for (int j2 = 0; j2 < nbands; j2++) {
sumChannels += pixel[j2];
}
BucketArray[i][j] = (sumChannels) / (nbands);
}
}
}
return BucketArray;
}
public PlanarImage PostProcessEmage(PlanarImage img) {
if (maskImgFName != null) {
int width = img.getWidth();
int height = img.getHeight();
// Get the number of bands on the image.
SampleModel sm = img.getSampleModel();
int nbands = sm.getNumBands();
// We assume that we can get the pixels values in a integer array.
double[] pixel = new double[nbands];
// Get an iterator for the image.
RandomIter iterator = RandomIterFactory.create(img, null);
WritableRaster rasterImage =
RasterFactory.createBandedRaster(
DataBuffer.TYPE_BYTE, width, height, nbands, new Point(0, 0));
double[] pixelNeighb = new double[nbands];
double[] pixelblack = new double[nbands];
for (int i = 0; i < nbands; i++) {
pixelNeighb[i] = 0;
pixelblack[i] = 0;
}
PlanarImage mask = JAI.create("FileLoad", maskImgFName);
RandomIter iteratorMask = RandomIterFactory.create(mask, null);
double[] pixelMask = new double[mask.getSampleModel().getNumBands()];
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
iteratorMask.getPixel(i, j, pixelMask);
if (!isBlack(pixelMask)) {
iterator.getPixel(i, j, pixel);
if (isWhite(pixel)) {;
} else {
rasterImage.setPixel(i, j, pixel);
}
} else {
rasterImage.setPixel(i, j, pixelblack);
}
}
}
SampleModel sModel2 =
RasterFactory.createBandedSampleModel(DataBuffer.TYPE_BYTE, width, height, nbands);
// Try to create a compatible ColorModel - if the number of bands is
// larger than 4, it will be null.
ColorModel cModel2 = PlanarImage.createColorModel(sModel2);
// Create a TiledImage using the sample and color models.
TiledImage processedImage = new TiledImage(0, 0, width, height, 0, 0, sModel2, cModel2);
// Set the data of the tiled image to be the raster.
processedImage.setData(rasterImage);
// Save the image to a file.
try {
ImageIO.write(processedImage, "jpg", new File("proc_" + theme + ".jpg"));
} catch (IOException e) {
log.error(e.getMessage());
}
// Save the image on a file.
return processedImage;
} else {
// Save the image to a file.
try {
ImageIO.write(img, "jpg", new File("NOTproc_" + theme + ".jpg"));
} catch (IOException e) {
log.error(e.getMessage());
}
return img;
}
}
public PlanarImage createRectifiedImage(PlanarImage Image) {
int nRows = params.getNumOfRows();
int nCols = params.getNumOfColumns();
Point rectifiedPoint;
// Get the image dimensions of the unrectified image
int width = Image.getWidth();
int height = Image.getHeight();
log.info(nRows + ", " + nCols + "\t" + width + ", " + height);
// Get an iterator for the image.
RandomIter iterator = RandomIterFactory.create(Image, null);
// Get the number of bands on the image.
SampleModel smO = Image.getSampleModel();
int nbandsO = smO.getNumBands();
// We assume that we can get the pixels values in a integer array.
double[] pixelO = new double[nbandsO];
// Get an iterator for the image.
WritableRaster rasterPollenO =
RasterFactory.createBandedRaster(
DataBuffer.TYPE_BYTE, nCols, nRows, nbandsO, new Point(0, 0));
for (int i = 0; i < nCols; i++) {
for (int j = 0; j < nRows; j++) {
rectifiedPoint =
this.getMatchingCoord(
new Point(i + 1, j + 1)); // coz java array start at 0 matlab its 1.
if (rectifiedPoint.x >= 1
&& rectifiedPoint.x < width
&& rectifiedPoint.y >= 1
&& rectifiedPoint.y < height) {
iterator.getPixel(rectifiedPoint.x - 1, rectifiedPoint.y - 1, pixelO);
rasterPollenO.setPixel(i, j, pixelO);
// log.info("setpixel: " + i + ", " + j + ", value " + pixelO[0] + ", " + pixelO[1] + ",
// " + pixelO[2] + ", " + pixelO[3]);
} else {
}
}
}
SampleModel sModel2 =
RasterFactory.createBandedSampleModel(DataBuffer.TYPE_BYTE, nCols, nRows, nbandsO);
// Try to create a compatible ColorModel - if the number of bands is
// larger than 4, it will be null.
ColorModel cModel2 = PlanarImage.createColorModel(sModel2);
// Create a TiledImage using the sample and color models.
TiledImage rectPollenImage = new TiledImage(0, 0, nCols, nRows, 0, 0, sModel2, cModel2);
// log.info(rasterPollenO.getMinX() + ", " + rasterPollenO.getMinY() );
// Set the data of the tiled image to be the raster.
rectPollenImage.setData(rasterPollenO);
// Save the image to a file.
try {
ImageIO.write(rectPollenImage, "jpg", new File("rect" + theme + ".jpg"));
} catch (IOException e) {
log.error(e.getMessage());
}
return rectPollenImage;
}
@Execute
public void process() throws Exception {
if (!concatOr(outIntensity == null, doReset)) {
return;
}
checkNull(
inVelocity,
pUpperThresVelocity,
pLowerThresVelocity, //
inWaterDepth,
pUpperThresWaterdepth,
pLowerThresWaterdepth, //
inErosionDepth,
pUpperThresErosionDepth,
pLowerThresErosionDepth, //
inDepositsThickness,
pUpperThresDepositsThickness,
pLowerThresDepositsThickness //
);
// do autoboxing only once
double maxWD = pUpperThresWaterdepth;
double minWD = pLowerThresWaterdepth;
double maxV = pUpperThresVelocity;
double minV = pLowerThresVelocity;
double maxED = pUpperThresErosionDepth;
double minED = pLowerThresErosionDepth;
double maxDT = pUpperThresDepositsThickness;
double minDT = pLowerThresDepositsThickness;
RegionMap regionMap = CoverageUtilities.getRegionParamsFromGridCoverage(inWaterDepth);
int nCols = regionMap.getCols();
int nRows = regionMap.getRows();
RandomIter waterdepthIter = CoverageUtilities.getRandomIterator(inWaterDepth);
RandomIter velocityIter = CoverageUtilities.getRandomIterator(inVelocity);
RandomIter erosiondepthIter = CoverageUtilities.getRandomIterator(inErosionDepth);
RandomIter depositThicknessIter = CoverageUtilities.getRandomIterator(inDepositsThickness);
WritableRaster outWR =
CoverageUtilities.createDoubleWritableRaster(nCols, nRows, null, null, doubleNovalue);
WritableRandomIter outIter = RandomIterFactory.createWritable(outWR, null);
pm.beginTask("Processing map...", nRows);
for (int r = 0; r < nRows; r++) {
if (isCanceled(pm)) {
return;
}
for (int c = 0; c < nCols; c++) {
double h = waterdepthIter.getSampleDouble(c, r, 0);
double v = velocityIter.getSampleDouble(c, r, 0);
double ed = erosiondepthIter.getSampleDouble(c, r, 0);
double dt = depositThicknessIter.getSampleDouble(c, r, 0);
if (isNovalue(h) && isNovalue(v) && isNovalue(ed) && isNovalue(dt)) {
continue;
} else if (!isNovalue(h) && !isNovalue(v) && !isNovalue(ed) && !isNovalue(dt)) {
double value = 0.0;
if (h > maxWD || v > maxV || dt > maxDT || ed > maxED) {
value = INTENSITY_HIGH;
} else if ((h <= maxWD && h > minWD)
|| //
(v <= maxV && v > minV)
|| //
(dt <= maxDT && dt > minDT)
|| //
(ed <= maxED && ed > minED)) {
value = INTENSITY_MEDIUM;
} else if (h <= minWD || v <= minV || dt <= minDT || ed <= minED) {
value = INTENSITY_LOW;
} else {
throw new ModelsIllegalargumentException(
"No intensity could be calculated for h = "
+ h
+ " and v = "
+ v
+ " and ed = "
+ ed
+ " and dt = "
+ dt,
this,
pm);
}
outIter.setSample(c, r, 0, value);
} else {
pm.errorMessage(
"WARNING: a cell was found in which one of velocity, water depth, erosion depth or deposit thickness are novalue, while the other not. /nThe maps should be covering the exact same cells. /nGoing on ignoring the cell: "
+ c
+ "/"
+ r);
}
}
pm.worked(1);
}
pm.done();
outIntensity =
CoverageUtilities.buildCoverage(
"intensity", outWR, regionMap, inWaterDepth.getCoordinateReferenceSystem());
}