public void removeLayersWithTexID(int texID, BTerrainTexturingLayer.eLayerType layerType, bool topLayerOnly)
{
//layer 0 is always a splat
if (mLayers.Count == 1)
{
mLayers[0].mActiveTextureIndex = 0;
return;
}
for (int i = 0; i < mLayers.Count; i++)
{
if (mLayers[i].mActiveTextureIndex == texID && mLayers[i].mLayerType == layerType)
{
clearLayerAlpha(i);
mLayers.RemoveAt(i);
i--;
if (topLayerOnly)
{
return;
}
}
}
fullLayerAlpha(0);
}
public int giveLayerID(int layerIndex, ref BTerrainTexturingLayer.eLayerType layerType)
{
if (layerIndex < 0 || layerIndex >= mLayers.Count)
{
layerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
return(-1);
}
layerType = mLayers[layerIndex].mLayerType;
return(mLayers[layerIndex].mActiveTextureIndex);
}
public void activeIndexRemovedCascade(int index, BTerrainTexturingLayer.eLayerType layerType)
{
//cascade
for (int i = 0; i < mLayers.Count; i++)
{
if (mLayers[i].mActiveTextureIndex >= index && mLayers[i].mLayerType == layerType)
{
mLayers[i].mActiveTextureIndex--;
}
}
}
public bool containsID(int activeTextureIndex, BTerrainTexturingLayer.eLayerType layerType)
{
for (int i = 0; i < mLayers.Count; i++)
{
if (mLayers[i].mActiveTextureIndex == activeTextureIndex &&
mLayers[i].mLayerType == layerType)
{
return(true);
}
}
return(false);
}
public int giveLayerIndex(int activeTextureIndex, BTerrainTexturingLayer.eLayerType layerType)
{
for (int i = 0; i < mLayers.Count; i++)
{
if (mLayers[i].mActiveTextureIndex == activeTextureIndex && mLayers[i].mLayerType == layerType)
{
return(i);
}
}
//not found;
return(-1);
}
public void initLayer(int layerID, int textureID, byte value, BTerrainTexturingLayer.eLayerType layerType)
{
while (mLayers.Count <= layerID)
{
mLayers.Add(new BTerrainPerVertexLayerData());
mLayers[mLayers.Count - 1].mLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
mLayers[mLayers.Count - 1].mActiveTextureIndex = textureID;
mLayers[mLayers.Count - 1].mAlphaContrib = 0;
}
mLayers[layerID].mAlphaContrib = value;
mLayers[layerID].mLayerType = layerType;
mLayers[layerID].mActiveTextureIndex = textureID;
}
public int giveLayerIDAtPixel(int x, int y, ref BTerrainTexturingLayer.eLayerType selectedLayerType, bool doSelectDecal)
{
int index = giveLayerIDAtPixelInternal(x, y, mLayers.Count - 1, ref selectedLayerType);
if (index == -1)
{
return(0);
}
if (selectedLayerType == BTerrainTexturingLayer.eLayerType.cLayer_Decal && doSelectDecal)
{
TerrainGlobals.getTexturing().selectActiveDecalInstance(mLayers[index].mActiveTextureIndex);
return(mLayers[index].mActiveTextureIndex);
}
return(index);
/*
* for (int i = mLayers.Count - 1; i >= 0; i--)
* {
*
* if (mLayers[i].mAlphaLayer[x + BTerrainTexturing.getAlphaTextureWidth() * y] != 0)
* {
* if (mLayers[i].mLayerType == BTerrainTexturingLayer.eLayerType.cLayer_Splat)
* {
* selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
* return mLayers[i].mActiveTextureIndex;
* }
* else
* {
* BTerrainDecalInstance dcli = TerrainGlobals.getTexturing().getActiveDecalInstance(mLayers[i].mActiveTextureIndex);
* if (TerrainGlobals.getEditor().mVisTileIntetersectionX <= dcli.mTileBoundsMax.X && TerrainGlobals.getEditor().mVisTileIntetersectionX >= dcli.mTileBoundsMin.X &&
* TerrainGlobals.getEditor().mVisTileIntetersectionZ <= dcli.mTileBoundsMax.Y && TerrainGlobals.getEditor().mVisTileIntetersectionZ >= dcli.mTileBoundsMin.Y)
* {
* if (doSelectDecal)
* TerrainGlobals.getTexturing().selectActiveDecalInstance(mLayers[i].mActiveTextureIndex);
*
* selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Decal;
* return dcli.mActiveDecalIndex;
* }
* }
* }
* }
*
* selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
* return mLayers[0].mActiveTextureIndex;
* */
}
public void addValueToTexID(int textureID, byte value, BTerrainTexturingLayer.eLayerType layerType)
{
//let's subtract this value from all indexes above us.
int index = giveLayerIndex(textureID, layerType);
if (index == -1)
{
index = newSplatLayer(textureID);
}
mLayers[index].mAlphaContrib = (byte)BMathLib.Clamp(mLayers[index].mAlphaContrib + value, 0, byte.MaxValue);
for (int i = index + 1; i < mLayers.Count; i++)
{
mLayers[i].mAlphaContrib = (byte)BMathLib.Clamp(mLayers[i].mAlphaContrib - value, 0, byte.MaxValue);
}
}
public int giveSplatLayerIDAtPixel(int x, int y)
{
BTerrainTexturingLayer.eLayerType reftype = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
int index = 0;
int start = mLayers.Count - 1;
while (reftype != BTerrainTexturingLayer.eLayerType.cLayer_Splat)
{
index = giveLayerIDAtPixelInternal(x, y, start, ref reftype);
if (index == -1)
{
return(0);
}
}
return(index);
}
public int giveDecalLayerIDAtPixel(int x, int y, bool doSelect)
{
BTerrainTexturingLayer.eLayerType reftype = BTerrainTexturingLayer.eLayerType.cLayer_Decal;
int index = 0;
int start = mLayers.Count - 1;
while (reftype != BTerrainTexturingLayer.eLayerType.cLayer_Decal)
{
index = giveLayerIDAtPixelInternal(x, y, start, ref reftype);
if (index == -1)
{
return(0);
}
}
if (doSelect)
{
TerrainGlobals.getTexturing().selectActiveDecalInstance(mLayers[index].mActiveTextureIndex);
}
return(index);
}
private int giveLayerIDAtPixelInternal(int x, int y, int startingLayer, ref BTerrainTexturingLayer.eLayerType selectedLayerType)
{
if (startingLayer > mLayers.Count - 1)
{
startingLayer = mLayers.Count - 1;
}
if (startingLayer < 0)
{
selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
return(0);
}
for (int i = startingLayer; i >= 0; i--)
{
if (mLayers[i].mAlphaLayer[x + BTerrainTexturing.getAlphaTextureWidth() * y] != 0)
{
if (mLayers[i].mLayerType == BTerrainTexturingLayer.eLayerType.cLayer_Splat)
{
selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
return(mLayers[i].mActiveTextureIndex);
}
else
{
BTerrainDecalInstance dcli = TerrainGlobals.getTexturing().getActiveDecalInstance(mLayers[i].mActiveTextureIndex);
if (TerrainGlobals.getEditor().mVisTileIntetersectionX <= dcli.mTileBoundsMax.X && TerrainGlobals.getEditor().mVisTileIntetersectionX >= dcli.mTileBoundsMin.X &&
TerrainGlobals.getEditor().mVisTileIntetersectionZ <= dcli.mTileBoundsMax.Y && TerrainGlobals.getEditor().mVisTileIntetersectionZ >= dcli.mTileBoundsMin.Y)
{
selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Decal;
return(i);// dcli.mActiveDecalIndex;
}
}
}
}
selectedLayerType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
return(-1);
}
//CLM USED FOR EXPORT
public unsafe void convertLayersToTexturingDataHandle(BTerrainLayerContainer input, List <Texture> tempAlphaTextures, BTerrainCompositeTexture output, int minXVert, int minZVert, int lod, int channelCount)
{
// BTerrainLayerContainer input = node.mLayerContainer;
// BTerrainCompositeTexture output = node.getTextureData(lod).mCompositeTexture;
Viewport vp = new Viewport();
vp.X = output.mXPixelOffset;
vp.Y = output.mYPixelOffset;
vp.Width = output.mWidth;
vp.Height = output.mWidth;
vp.MinZ = 0;
vp.MaxZ = 1;
BRenderDevice.getDevice().Viewport = vp;
Microsoft.DirectX.Direct3D.Effect shader = TerrainGlobals.getTexturing().mCompositeShader;
shader.Begin(0);
shader.BeginPass(0);
for (int i = 0; i < channelCount; i++)
{
for (int k = 0; k < output.mNumMips; k++)
{
//actually render
Surface compositeTarget = null;
float scale = 1;
try
{
if (output.UsingAtlas == false)
{
compositeTarget = output.mTextures[i].GetSurfaceLevel(k);
BRenderDevice.getDevice().SetRenderTarget(0, compositeTarget);
}
else
{
BTerrainCompositeAtlasTexture atlas = output.mAtlas;
if (atlas.mTextures[i].Disposed == true)
{
atlas.reCreate();
}
scale = atlas.mAtlasScale;
compositeTarget = atlas.mTextures[i].GetSurfaceLevel(k);
BRenderDevice.getDevice().SetRenderTarget(0, compositeTarget);
}
{
BTerrainTexturingLayer.eLayerType lastType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
float layerInc = 1.0f / (float)(cMaxNumBlends - 1);// (float)input.getNumLayers();
for (int j = 0; j < input.getNumLayers(); j++)
{
// BRenderDevice.getDevice().Clear(ClearFlags.ZBuffer | ClearFlags.Target, unchecked((int)0xFFFF0000), 1.0f, 0);
//compose a splat
shader.SetValue(mShaderContribOverride, 1);
shader.SetValue(mShaderAlphaOverride, 1);
if (input.giveLayer(j).mLayerType == BTerrainTexturingLayer.eLayerType.cLayer_Splat)
{
if (lastType != BTerrainTexturingLayer.eLayerType.cLayer_Splat)
{
shader.EndPass();
shader.BeginPass(0);
lastType = BTerrainTexturingLayer.eLayerType.cLayer_Splat;
}
if (TerrainGlobals.getEditor().getRenderMode() == BTerrainEditor.eEditorRenderMode.cRenderTextureSelectRender)
{
if (TerrainGlobals.getEditor().getMode() != BTerrainEditor.eEditorMode.cModeTexEdit)
{
if (j == 0)
{
shader.SetValue(mShaderContribOverride, 0);
shader.SetValue(mShaderAlphaOverride, 0);
}
else
{
continue;
}
}
else
{
if (input.giveLayer(j).mActiveTextureIndex != TerrainGlobals.getTerrainFrontEnd().SelectedTextureIndex)
{
shader.SetValue(mShaderContribOverride, 0);
}
else
{
shader.SetValue(mShaderContribOverride, 1);
}
shader.SetValue(mShaderAlphaOverride, 0);
}
}
float targetLayer = (float)(j * layerInc);
shader.SetValue(mShaderNumLayersHandle, targetLayer);
shader.SetValue(mShaderAlphaTexArrayHandle, tempAlphaTextures[j]);
//lock in our target texture
BTerrainActiveTextureContainer active = TerrainGlobals.getTexturing().getActiveTexture(input.giveLayer(j).mActiveTextureIndex);
if (active == null)
{
compositeTarget.Dispose();
continue;
}
shader.SetValue(mShaderTexArrayHandle, active.mTexChannels[i].mTexture);
float[] uvs = new float[2];
uvs[0] = active.mUScale;
uvs[1] = active.mVScale;
shader.SetValue(mShaderLayerUV, uvs);
}
else //compose a decal
{
if (lastType != BTerrainTexturingLayer.eLayerType.cLayer_Decal)
{
shader.EndPass();
shader.BeginPass(1);
lastType = BTerrainTexturingLayer.eLayerType.cLayer_Decal;
}
bool doWhite = false;
if (TerrainGlobals.getEditor().getRenderMode() == BTerrainEditor.eEditorRenderMode.cRenderTextureSelectRender)
{
if (TerrainGlobals.getEditor().getMode() == BTerrainEditor.eEditorMode.cModeTexEdit)
{
shader.SetValue(mShaderContribOverride, 0);
}
else if (TerrainGlobals.getEditor().getMode() == BTerrainEditor.eEditorMode.cModeDecalEdit)
{
doWhite = true;
if (TerrainGlobals.getTexturing().getActiveDecalInstance(input.giveLayer(j).mActiveTextureIndex).mActiveDecalIndex != TerrainGlobals.getTerrainFrontEnd().SelectedDecalIndex)
{
shader.SetValue(mShaderContribOverride, 0);
}
else
{
shader.SetValue(mShaderContribOverride, 1);
shader.SetValue(mShaderAlphaOverride, 1);
}
}
}
//Grab our decal instance
BTerrainDecalInstance decal = getActiveDecalInstance(input.giveLayer(j).mActiveTextureIndex);
if (decal == null)
{
compositeTarget.Dispose();
continue;
}
Vector4 selColor = new Vector4(1, 1, 1, 1);
if (decal.mIsSelected)
{
selColor.Y = 0.75f;
selColor.Z = 0.75f;
}
shader.SetValue(mShaderColorOverload, selColor);
//grab the decal we care about
BTerrainActiveDecalContainer active = getActiveDecal(decal.mActiveDecalIndex);
if (active == null)
{
compositeTarget.Dispose();
continue;
}
if (doWhite)
{
shader.SetValue(mShaderAlphaTexArrayHandle, tempAlphaTextures[0]);
}
else
{
shader.SetValue(mShaderAlphaTexArrayHandle, tempAlphaTextures[j]);
}
shader.SetValue(mShaderAlphaTexDecalHandle, active.mTexChannels[(int)BTerrainTexturing.eTextureChannels.cOpacity].mTexture);
shader.SetValue(mShaderTexDecalHandle, active.mTexChannels[i].mTexture);
float[] decalDat = new float[4];
decalDat[0] = decal.mRotation;
//compute our U and V offset
float vertsToHighResPixelSpaceRatio = BTerrainTexturing.getTextureWidth() / BTerrainQuadNode.cMaxWidth;
decalDat[1] = (decal.mTileCenter.X - (minXVert * vertsToHighResPixelSpaceRatio)) / BTerrainTexturing.getTextureWidth();
decalDat[2] = (decal.mTileCenter.Y - (minZVert * vertsToHighResPixelSpaceRatio)) / BTerrainTexturing.getTextureHeight();
decalDat[3] = 0;
shader.SetValue(mShaderLayerDecalData, decalDat);
float[] uvs = new float[2];
uvs[0] = decal.mUScale;
uvs[1] = decal.mVScale;
shader.SetValue(mShaderLayerUV, uvs);
}
shader.CommitChanges();
BRenderDevice.getDevice().Viewport = vp;
BRenderDevice.getDevice().DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 4, 0, 2);
}
shader.EndPass();
shader.BeginPass(0);
}
}
catch (Direct3DXException e)
{
CoreGlobals.getErrorManager().SendToErrorWarningViewer("An error has occured during the compositing process");
}
finally
{
if (compositeTarget != null)
{
compositeTarget.Dispose();
}
}
}
}
shader.EndPass();
shader.End();
}
void fillCreateLayer(byte[] inputImg, int activeTexIndex, BTerrainTexturingLayer.eLayerType type, int minXTile, int minZTile, byte[] tempLargerImge, byte[] tempBorderedImg)
{
int width = (int)BTerrainTexturing.getAlphaTextureWidth();
int height = (int)BTerrainTexturing.getAlphaTextureHeight();
int lw = width + 2;
int lh = height + 2;
//Create our texture first, border it, then resize it.
//fill the origional texture into the new texture
for (int q = 0; q < (width); q++)
{
for (int j = 0; j < (height); j++)
{
tempLargerImge[(q + 1) + lw * (j + 1)] = inputImg[q + (width) * j];
}
}
int numXNodes = (int)(TerrainGlobals.getTerrain().getNumXVerts() / BTerrainQuadNode.cMaxWidth);
int rootXNode = (int)(minXTile / BTerrainQuadNode.cMaxWidth);
int rootZNode = (int)(minZTile / BTerrainQuadNode.cMaxHeight);
BTerrainQuadNode rootNode = TerrainGlobals.getTerrain().getLeafNode(rootXNode, rootZNode);//TerrainGlobals.getTerrain().getQuadNodeRoot().getLeafNodeContainingTile(minXTile, minZTile);
BTerrainQuadNode node = null;
int layerIndex = 0;
BTerrainTexturingLayer lyr = null;
#region SIDES
//grab neighbor alpha values, paste them into my edges.
//LEFT SIDE FILL
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode - 1, rootZNode);// rootNode.getNeighborNode(-1, 0);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the RIGHT pixels
for (int i = 0; i < height; i++)
{
int srcIndex = (width - 1) + width * i;
int destIndex = 0 + (lw * (i + 1));
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//extend the LEFT pixels
for (int i = 0; i < height; i++)
{
int srcIndex = 0 + width * i;
int destIndex = 0 + (lw * (i + 1));
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
//RIGHT SIDE FILL
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode + 1, rootZNode);// rootNode.getNeighborNode(1, 0);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the LEFT pixels
for (int i = 0; i < height; i++)
{
int srcIndex = 0 + width * i;
int destIndex = (lw - 1) + (lw * (i + 1));
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
else
{
//extend the RIGHT pixels
for (int i = 0; i < height; i++)
{
int srcIndex = (width - 1) + width * i;
int destIndex = (lw - 1) + (lw * (i + 1));
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
//TOP SIDE FILL
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode, rootZNode + 1);// rootNode.getNeighborNode(0, 1);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the BOTTOM pixels
for (int i = 0; i < width; i++)
{
int srcIndex = i + width * 0;
int destIndex = (i + 1) + (lw * (lh - 1));
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//extend the TOP pixels
for (int i = 0; i < width; i++)
{
int srcIndex = i + width * (height - 1);
int destIndex = (i + 1) + (lw * (lh - 1));
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
//BOTTOM SIDE FILL
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode, rootZNode - 1);// rootNode.getNeighborNode(0, -1);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the TOP pixels
for (int i = 0; i < width; i++)
{
int srcIndex = i + width * (height - 1);
int destIndex = (i + 1) + (lw * 0);
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//extend the BOTTOM pixels
for (int i = 0; i < width; i++)
{
int srcIndex = i + width * 0;
int destIndex = (i + 1) + (0);
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
#endregion
#region CORNERS
//TOP LEFT CORNER
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode - 1, rootZNode + 1);//rootNode.getNeighborNode(-1, 1);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the BOTTOM RIGHT pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = (width - 1) + width * 0;
int destIndex = 0 + (lw * (lh - 1));
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//grab the tpo+1, left+1 pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = 1 + width * (height - 2);
int destIndex = 0 + (lw * (lh - 1));
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
//TOP RIGHT CORNER
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode + 1, rootZNode + 1);//rootNode.getNeighborNode(1, 1);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the BOTTOM LEFT pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = 0;// +width * (height - 1);
int destIndex = (lw - 1) + (lw * (lh - 1));
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//grab the TOP+1 RIGHT+1 pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = (width - 2) + width * (height - 2);
int destIndex = (lw - 1) + (lw * (lh - 1));
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
//BOTTOM LEFT CORNER
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode - 1, rootZNode - 1);//rootNode.getNeighborNode(-1, -1);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the TOP RIGHT pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = (width - 1) + width * (height - 1);
int destIndex = 0 + (lw * 0);
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//grab the BOTTOM+1 LEFT+1 pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = 1 + width * 1;
int destIndex = 0 + (lw * 0);
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
//BOTTOM RIGHT CORNER
node = TerrainGlobals.getTerrain().getLeafNode(rootXNode + 1, rootZNode - 1);//rootNode.getNeighborNode(1, -1);
if ((node != null) &&
((layerIndex = node.mLayerContainer.giveLayerIndex(activeTexIndex, type)) != -1))
{
{
lyr = node.mLayerContainer.giveLayer(layerIndex);
//grab the TOP LEFT pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = (0) + width * (height - 1);
int destIndex = (lw - 1) + (lw * 0);
tempLargerImge[destIndex] = lyr.mAlphaLayer[srcIndex];
}
}
}
else
{
//grab the BOTTOM+1 RIGHT+1 pixel
//for (int i = 0; i < width; i++)
{
int srcIndex = (width - 2) + width * 1;
int destIndex = (lw - 1) + (lw * 0);
tempLargerImge[destIndex] = inputImg[srcIndex];
}
}
#endregion
ImageManipulation.resizeGreyScaleImg(tempLargerImge, tempBorderedImg, width + 2, height + 2, width, height, ImageManipulation.eFilterType.cFilter_Linear);
}
