override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { int tx = FlipHorizontal ? parms.Width - x - 1 : x; int ty = FlipVertical ? parms.Height - y - 1 : y; mp.Value[x, y] = InputMask[tx, ty]; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = mp.Value[x, y] * Gain + Bias; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } gatherInputAndParameters(parms); NoiseGeneration.RigedMultiFractal pl = new NoiseGeneration.RigedMultiFractal(); pl.mSeed = this.SeedParam; pl.mOctaveCount.Value = this.OctaveParam; pl.mFrequency.Value = this.Frequency; pl.mLacunarity.Value = this.Lacunarity; int sWidth = 128; int sHeight = 128; MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(parms.Width, parms.Height); mp.Value.mConstraintMask = ConstraintMask; for (int y = 0; y < parms.Height; y++) { for (int x = 0; x < parms.Width; x++) { mp.Value[x, y] = BMathLib.Clamp((float)((pl.getValue((x / (float)parms.Width) * sWidth, (y / (float)parms.Height) * sHeight, 0) + 1) * 0.5f), 0, 1); } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); if (InputChoice) { mp.Value = InputMaskA.Clone(); } else { mp.Value = InputMaskB.Clone(); } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(InputMask.Width, InputMask.Height); for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { Vector2 v = TerrainGlobals.getTerrain().getGradiant(x, y); float factor = BMathLib.Clamp(v.Length(), 0, 1); if (factor < 0) { continue; } mp.Value[x, y] = factor; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; int numTimesToRun = parms.Width >> 1; DAGMask outMask = InputMask.Clone();// DAGMask distMask = new DAGMask(parms.Width, parms.Height); int maxRange = 0; for (int i = 0; i < numTimesToRun; i++) { DAGMask smallerMask = new DAGMask(parms.Width, parms.Height); bool madeChange = contractSetValue(ref outMask, ref smallerMask, ref distMask, i); outMask = smallerMask.Clone(); if (madeChange) { maxRange = i; } else { break; } } //normalize our input now... for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = distMask[x, y] / (float)maxRange; } } outMask = null; return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } gatherInputAndParameters(parms); MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(parms.Width, parms.Height); float mx = CoreGlobals.getEditorMain().mITerrainShared.getBBMax().Y; float mn = CoreGlobals.getEditorMain().mITerrainShared.getBBMin().Y; float delta = mx - mn; int numXVerts = CoreGlobals.getEditorMain().mITerrainShared.getNumXVerts(); int numZVerts = CoreGlobals.getEditorMain().mITerrainShared.getNumXVerts(); float[] fk = new float[numXVerts * numZVerts]; for (int x = 0; x < numXVerts; x++) { for (int y = 0; y < numZVerts; y++) { fk[x + numXVerts * y] = CoreGlobals.getEditorMain().mITerrainShared.getTerrainHeight(x, y); } } if (numXVerts != parms.Width || numZVerts != parms.Height) { float[] resizedHeights = ImageManipulation.resizeF32Img(fk, numXVerts, numZVerts, parms.Width, parms.Height, ImageManipulation.eFilterType.cFilter_Linear); fk = (float[])resizedHeights.Clone(); } for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { float k = fk[x + parms.Width * y]; k -= mn; k /= delta; mp.Value[x, y] = k; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } setNoiseParms(); MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; for (int y = 0; y < parms.Height; y++) { for (int x = 0; x < parms.Width; x++) { float x0, y0; float x1, y1; float x2, y2; x0 = x + (12414.0f / 65536.0f); y0 = y + (65124.0f / 65536.0f); x1 = x + (26519.0f / 65536.0f); y1 = y + (18128.0f / 65536.0f); x2 = x + (53820.0f / 65536.0f); y2 = y + (11213.0f / 65536.0f); float xDistort = ((float)(mXDistort.getValue(x0, y0, 0) * Power)); float yDistort = ((float)(mYDistort.getValue(x1, y1, 0) * Power)); int kx = (int)BMathLib.Clamp(x + (int)(xDistort * parms.Width), 0, parms.Width - 1); int ky = (int)BMathLib.Clamp(y + (int)(yDistort * parms.Height), 0, parms.Height - 1); mp.Value[x, y] = InputMask[kx, ky]; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } gatherInputAndParameters(parms); MaskParam mp = ((MaskParam)(connPoint.ParamType)); // mp.Value = InputMask.Clone(); DAGMask baseMask = InputMask.Clone(); DAGMask addMask = new DAGMask(parms.Width, parms.Height); DAGMask subMask = new DAGMask(parms.Width, parms.Height); //if we're doing multiscale erosion if (MultiscaleEnable) { //subtract multiscale mask from our base mask before doing erosion multiscaleDisplace(ref baseMask, ref subMask, ref addMask); } //CLM it actually looks better (less noisy) w/o this high fidelity step! calculateErosion(baseMask, baseMask.Width, baseMask.Height, ref subMask, ref addMask, 0); //calculate our mask 'channels' for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { baseMask[x, y] = baseMask[x, y] + addMask[x, y] - subMask[x, y]; } } //need to find which output this connection point is connected to... mp.Value = baseMask.Clone(); return(true); }
public void generatePreview(CanvasNode cn) { OutputGenerationParams ogp = new OutputGenerationParams(); ogp.Width = 128; ogp.Height = 128; MaskDAGGraphNode gn = (MaskDAGGraphNode)cn; MaskParam mp = new MaskParam(); InputConnectionPoint icp = new InputConnectionPoint(mp,true,"Preview",gn,this); gn.computeOutput(icp,ogp); if (onUpdateCallback != null) { DAGMask m = mp.Value; onUpdateCallback(ref m); } }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; if (ClampType == (int)eMethod.eScale) //scale between the values { float delta = MaxHeight - MinHeight; for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = MinHeight + (InputMask[x, y] * delta); } } } else if (ClampType == (int)eMethod.eClamp) //actually clamp { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = BMathLib.Clamp(InputMask[x, y], MinHeight, MaxHeight); } } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } //this is a splitter, so we need to duplicate the input values.. MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } gatherInputAndParameters(parms); MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(parms.Width, parms.Height); mp.Value.mConstraintMask = ConstraintMask; mp.Value.setAllToValue(Value); return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } gatherInputAndParameters(parms); System.Drawing.Drawing2D.Matrix mTransformMat = new Matrix(); mTransformMat.Translate(-(parms.Width >> 1), -(parms.Height >> 1)); mTransformMat.Rotate(Direction, MatrixOrder.Append); mTransformMat.Translate((parms.Width >> 1), (parms.Height >> 1), MatrixOrder.Append); MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(parms.Width, parms.Height); mp.Value.mConstraintMask = ConstraintMask; Point[] pts = new Point[1]; float incStep = 1.0f / parms.Width; for (int y = 0; y < parms.Height; y++) { for (int x = 0; x < parms.Width; x++) { pts[0].X = x; pts[0].Y = y; mTransformMat.TransformPoints(pts); mp.Value[x, y] = incStep * pts[0].X; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; DAGMask outMask = InputMask.Clone(); for (int i = 0; i < NumPixels; i++) { DAGMask smallerMask = new DAGMask(parms.Width, parms.Height); contractSetValue(ref outMask, ref smallerMask); outMask = smallerMask.Clone(); } //normalize our input now... for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = outMask[x, y]; } } outMask = null; return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(InputMask.Width, InputMask.Height); for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { if (InputMask[x, y] >= MinHeight && InputMask[x, y] <= MaxHeight) { mp.Value[x, y] = 1.0f; } else if (InputMask[x, y] >= MinHeight - FalloffAmt && InputMask[x, y] <= MinHeight) { mp.Value[x, y] = 1 - ((MinHeight - InputMask[x, y]) / FalloffAmt); } else if (InputMask[x, y] >= MaxHeight && InputMask[x, y] <= MaxHeight + FalloffAmt) { mp.Value[x, y] = 1 - ((InputMask[x, y] - MaxHeight) / FalloffAmt); } else { mp.Value[x, y] = 0; } } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; SplineInterpolator interpolator = new SplineInterpolator(); for (int i = 0; i < ControlPointsKeys.Count; ++i) { interpolator.Add(ControlPointsKeys[i], ControlPointsValues[i]); } for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { float v = mp.Value[x, y]; mp.Value[x, y] = (float)interpolator.Interpolate(v); } } interpolator.Clear(); interpolator = null; return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } gatherInputAndParameters(parms); MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(parms.Width, parms.Height); mp.Value.mConstraintMask = ConstraintMask; int xOffset = parms.Width >> 1; int yOffset = parms.Height >> 1; int radius = (int)(Radius * parms.Width); int hotRadius = (int)(radius * HotSpot); int diff = (int)(radius - hotRadius); int mnX = Math.Max(0, xOffset - radius); int mnY = Math.Max(0, yOffset - radius); int mxX = Math.Min(parms.Width - 1, xOffset + radius); int mxY = Math.Min(parms.Height - 1, yOffset + radius); for (int i = mnX; i < mxX; i++) { for (int j = mnY; j < mxY; j++) { float gradVal = 0; float dist = (float)Math.Sqrt((xOffset - i) * (xOffset - i) + (yOffset - j) * (yOffset - j)); if (dist < radius) { if (dist < hotRadius) { gradVal = 1.0f; } else { float gradDiff = 1 - ((dist - (hotRadius)) / (float)(diff)); gradVal = gradDiff; } } if (gradVal == 0) { continue; } mp.Value[i, j] = Intensity * gradVal; } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(InputMask.Width, InputMask.Height); float tileScale = 1.0f; for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { //CLM [02.18.08] this uses the calculation of the Gradiant for a given heightfield element // That is, the partial derivitive of the element. // taking the length approximates how much gradation exists in either the X or Y directions. int px = (int)BMathLib.Clamp(x + 1, 0, parms.Width - 1); int py = (int)BMathLib.Clamp(y + 1, 0, parms.Height - 1); int nx = (int)BMathLib.Clamp(x - 1, 0, parms.Width - 1); int ny = (int)BMathLib.Clamp(y - 1, 0, parms.Height - 1); float vX = (InputMask[px, y] - InputMask[nx, y]) / (2 * tileScale); float vY = (InputMask[x, py] - InputMask[x, ny]) / (2 * tileScale); float vLen = (float)Math.Sqrt(vX * vX + vY * vY); float slope = BMathLib.Saturate(vLen); if (slope >= MinSlope && slope <= MaxSlope) { mp.Value[x, y] = 1.0f; } else if (slope >= MinSlope - FalloffAmt && slope <= MinSlope) { mp.Value[x, y] = 1 - ((MinSlope - slope) / FalloffAmt); } else if (slope >= MaxSlope && slope <= MaxSlope + FalloffAmt) { mp.Value[x, y] = 1 - ((slope - MaxSlope) / FalloffAmt); } else { mp.Value[x, y] = 0; } } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(InputMaskA.Width, InputMaskA.Height); mp.Value.mConstraintMask = ConstraintMask; if (Method == (int)eMethod.eAverage) //AVERAGE { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = (InputMaskA[x, y] + InputMaskB[x, y]) * Strength[x, y]; } } } else if (Method == (int)eMethod.eAdd) //ADD { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = InputMaskA[x, y] + (InputMaskB[x, y] * Strength[x, y]); } } } else if (Method == (int)eMethod.eSubtract) //SUBTRACT { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = InputMaskA[x, y] - (InputMaskB[x, y] * Strength[x, y]); } } } else if (Method == (int)eMethod.eMultiply) //MULTIPLY { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = InputMaskA[x, y] * InputMaskB[x, y] * Strength[x, y]; } } } else if (Method == (int)eMethod.eMax) //MAX { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = Math.Max(InputMaskA[x, y], InputMaskB[x, y]); } } } else if (Method == (int)eMethod.eMin) //MIN { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = Math.Min(InputMaskA[x, y], InputMaskB[x, y]); } } } else if (Method == (int)eMethod.eLerp) //LERP { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = ((1.0f - Strength[x, y]) * InputMaskA[x, y]) + (Strength[x, y] * InputMaskB[x, y]); } } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; ConvMatrix filter = new ConvMatrix(1, 2, 1, 2, 4, 2, 1, 2, 1); filter.mFactor = 16; filter.mOffset = 0; for (int i = 0; i < SmoothPower; i++) { int[] neightbors = new int[] { -1, 1, //top left 0, 1, //top center 1, 1, //top right -1, 0, //mid left 0, 0, //mid center 1, 0, //mid right -1, -1, //bot left 0, -1, //bot center 1, -1, //bot right }; DAGMask tempImgArray = new DAGMask(parms.Width, parms.Height); for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { float total = 0; for (int k = 0; k < 9; k++) { int xIndex = x + neightbors[k * 2]; int zIndex = y + neightbors[k * 2 + 1]; if (xIndex < 0 || xIndex > parms.Width - 1 || zIndex < 0 || zIndex > parms.Height - 1) { continue; } total += filter.mFilterCoeffs[k] * mp.Value[xIndex, zIndex]; } total = total / filter.mFactor + filter.mOffset; if (total > 1.0f) { total = 1.0f; } if (total < 0) { total = 0; } tempImgArray[x, y] = total; } } //send our mask back for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = BMathLib.Clamp(tempImgArray[x, y], 0, 1); } } tempImgArray = null; } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; float modStep = 1.0f / NumTerraces; if (Method == (int)eMethod.eSimple) { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { float dc = InputMask[x, y] % modStep; mp.Value[x, y] = InputMask[x, y] - dc; } } } else if (Method == (int)eMethod.eSharp) { for (int y = 0; y < parms.Height; y++) { for (int x = 0; x < parms.Width; x++) { //find our low step float val = InputMask[x, y]; float low = val - (val % modStep); float high = low + modStep; float posalpha = (val - low) / (high - low); posalpha *= posalpha; float posVal = ((1.0f - posalpha) * low) + (posalpha * high); float negalpha = (val - low) / (high - low); negalpha = 1.0f - negalpha; { float v = low; low = high; high = v; } negalpha *= negalpha; float negVal = ((1.0f - negalpha) * low) + (negalpha * high); //lerp between neg and pos values mp.Value[x, y] = ((1.0f - TerraceShape) * negVal) + (TerraceShape * posVal); } } } //else if (Method == (int)eMethod.eSmooth) //{ //} return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (SelectedMaskName == null || SelectedMaskName == "") { return(false); } gatherInputAndParameters(parms); ArrayBasedMask terrMask = null; IMask msk = CoreGlobals.getEditorMain().mIMaskPickerUI.GetMask(SelectedMaskName); if (msk == null) { return(false); } if (msk is ArrayBasedMask) { terrMask = msk as ArrayBasedMask; } else if (msk is GraphBasedMask) { //we have to generate this mask... if (((GraphBasedMask)msk).loadAndExecute()) { terrMask = ((GraphBasedMask)msk).getOutputMask(); } } int numXVerts = CoreGlobals.getEditorMain().mITerrainShared.getNumXVerts(); int numZVerts = CoreGlobals.getEditorMain().mITerrainShared.getNumXVerts(); float[] fk = new float[numXVerts * numZVerts]; for (int x = 0; x < numXVerts; x++) { for (int y = 0; y < numZVerts; y++) { fk[x + numXVerts * y] = terrMask.GetValue(x * numXVerts + y); } } if (numXVerts != parms.Width || numZVerts != parms.Height) { float[] resizedHeights = ImageManipulation.resizeF32Img(fk, numXVerts, numZVerts, parms.Width, parms.Height, ImageManipulation.eFilterType.cFilter_Linear); fk = (float[])resizedHeights.Clone(); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = new DAGMask(parms.Width, parms.Height); for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { float k = fk[x + parms.Width * y]; mp.Value[x, y] = k; } } terrMask = null; msk = null; return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; int r = Radius; int[] w = CreateGaussianBlurRow(r); int wlen = w.Length; DAGMask tmpMask = new DAGMask(parms.Width, parms.Height); { float[] waSums = new float[wlen]; float[] wcSums = new float[wlen]; float[] aSums = new float[wlen]; for (int y = 0; y < parms.Height; ++y) { float waSum = 0; float wcSum = 0; float aSum = 0; int dstx = 0; for (int wx = 0; wx < wlen; ++wx) { int srcX = wx - r; waSums[wx] = 0; wcSums[wx] = 0; aSums[wx] = 0; if (srcX >= 0 && srcX < parms.Width) { for (int wy = 0; wy < wlen; ++wy) { int srcY = y + wy - r; if (srcY >= 0 && srcY < parms.Height) { float c = InputMask[srcX, srcY]; float wp = w[wy]; waSums[wx] += wp; wp *= c;// +(c >> 7); wcSums[wx] += wp; //wp >>= 8; aSums[wx] += wp * c; } } int wwx = w[wx]; waSum += wwx * waSums[wx]; wcSum += wwx * wcSums[wx]; aSum += wwx * aSums[wx]; } } // wcSum >>= 8; if (waSum == 0 || wcSum == 0) { tmpMask[dstx, y] = 0; } else { tmpMask[dstx, y] = aSum / waSum; } ++dstx; for (int x = 1; x < parms.Width; ++x) { for (int i = 0; i < wlen - 1; ++i) { waSums[i] = waSums[i + 1]; wcSums[i] = wcSums[i + 1]; aSums[i] = aSums[i + 1]; } waSum = 0; wcSum = 0; aSum = 0; int wx; for (wx = 0; wx < wlen - 1; ++wx) { float wwx = w[wx]; waSum += wwx * waSums[wx]; wcSum += wwx * wcSums[wx]; aSum += wwx * aSums[wx]; } wx = wlen - 1; waSums[wx] = 0; wcSums[wx] = 0; aSums[wx] = 0; int srcX = x + wx - r; if (srcX >= 0 && srcX < parms.Width) { for (int wy = 0; wy < wlen; ++wy) { int srcY = y + wy - r; if (srcY >= 0 && srcY < parms.Height) { float c = InputMask[srcX, srcY]; float wp = w[wy]; waSums[wx] += wp; wp *= c;// +(c >> 7); wcSums[wx] += wp; //wp >>= 8; aSums[wx] += wp * c; } } int wr = w[wx]; waSum += wr * waSums[wx]; wcSum += wr * wcSums[wx]; aSum += wr * aSums[wx]; } // wcSum >>= 8; if (waSum == 0 || wcSum == 0) { tmpMask[x, y] = 0; } else { tmpMask[x, y] = (aSum / waSum); } ++dstx; } } } //copy back for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = tmpMask[x, y]; } } tmpMask = null; return(true); }
protected void generateConnectionPoints() { List <string> usedDescriptions = new List <string>(); //try to do this dynamically... Type type = GetType();// Get object type System.Reflection.PropertyInfo[] pi = type.GetProperties(); for (int i = 0; i < pi.Length; i++) { System.Reflection.PropertyInfo prop = pi[i]; object[] custAttrib = prop.GetCustomAttributes(false); if (custAttrib == null) { continue; } ParamType pt = null; Type ptt = prop.PropertyType; if (ptt == typeof(float)) { pt = new FloatParam(); } else if (ptt == typeof(int)) { pt = new IntParam(); } else if (ptt == typeof(bool)) { pt = new BoolParam(); } else if (ptt == typeof(DAGMask)) { pt = new MaskParam(); } for (int k = 0; k < custAttrib.Length; k++) { if (custAttrib[k] is ConnectionType) { ConnectionType ct = custAttrib[k] as ConnectionType; //make sure this connection is unique for (int j = 0; j < usedDescriptions.Count; j++) { if (ct.Description == usedDescriptions[j]) { MessageBox.Show(type.FullName + " has already defined a connection value with description " + ct.Description); System.Diagnostics.Debug.Assert(false); return; } } if (ct.ConnType == "Param") { addParamConnectionPoint(pt, ct.Description); } else if (ct.ConnType == "Input") { addInputConnectionPoint(pt, ct.Description, ct.Required); } else if (ct.ConnType == "Output") { addOutputConnectionPoint(pt, ct.Description); } else if (ct.ConnType == "Constraint") { addConstraintConnectionPoint(pt, ct.Description); } else { System.Diagnostics.Debug.Assert(false, "Unrecognized connection type listed for object " + type.FullName); } usedDescriptions.Add(ct.Description); break; } } } }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; /////////////////////////////////////////////////////////////// int width = parms.Width; int height = parms.Height; int rad = Radius; int[] leadingEdgeX = new int[rad + 1]; // approximately (rad + 0.5)^2 int cutoff = ((rad * 2 + 1) * (rad * 2 + 1) + 2) / 4; for (int v = 0; v <= rad; ++v) { for (int u = 0; u <= rad; ++u) { if (u * u + v * v <= cutoff) { leadingEdgeX[v] = u; } } } const int hLength = 256; int[] ha = new int[hLength]; for (int y = 0; y < parms.Height; y++) { //calculate our histogram.. for (int k = 0; k < hLength; k++) { ha[k] = 0; } int area = 0; int maxArea = GetMaxAreaForRadius(rad); int top = -Math.Min(rad, y); int bottom = Math.Min(rad, height - 1 - y); int left = -Math.Min(rad, 0); int right = Math.Min(rad, width - 1); for (int v = top; v <= bottom; ++v) { for (int u = left; u <= right; ++u) { byte psamp = (byte)(InputMask[u, y + v] * 255); if ((u * u + v * v) <= cutoff) { ++area; ++ha[psamp]; } } } for (int x = 0; x < parms.Width; x++) { mp.Value[x, y] = GetPercentile(Percent, area, ref ha) / 255.0f; left = -Math.Min(rad, x); right = Math.Min(rad + 1, width - 1 - x); // Subtract trailing edge top half int v = -1; while (v >= top) { int u = leadingEdgeX[-v]; if (-u >= left) { break; } --v; } while (v >= top) { int u = leadingEdgeX[-v]; byte p = (byte)(InputMask[x - u, y + v] * 255); --ha[p]; --area; --v; } // add leading edge top half v = -1; while (v >= top) { int u = leadingEdgeX[-v]; if (u + 1 <= right) { break; } --v; } while (v >= top) { int u = leadingEdgeX[-v]; byte p = (byte)(InputMask[x + u + 1, y + v] * 255); ++ha[p]; ++area; --v; } // Subtract trailing edge bottom half v = 0; while (v <= bottom) { int u = leadingEdgeX[v]; if (-u >= left) { break; } ++v; } while (v <= bottom) { int u = leadingEdgeX[v]; byte p = (byte)(InputMask[x - u, y + v] * 255); --ha[p]; --area; ++v; } // add leading edge bottom half v = 0; while (v <= bottom) { int u = leadingEdgeX[v]; if (u + 1 <= right) { break; } ++v; } while (v <= bottom) { int u = leadingEdgeX[v]; byte p = (byte)(InputMask[x + u + 1, y + v] * 255); ++ha[p]; ++area; ++v; } } } return(true); }
override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms) { if (!verifyInputConnections()) { return(false); } if (!gatherInputAndParameters(parms)) { return(false); } MaskParam mp = ((MaskParam)(connPoint.ParamType)); mp.Value = InputMask.Clone(); mp.Value.mConstraintMask = ConstraintMask; int workWidth = parms.Width - 1; int workHeight = parms.Height - 1; int halfWid = parms.Width >> 1; int halfHei = parms.Height >> 1; if (Method == (int)eMethod.eLeftToRight) { for (int x = 0; x < halfWid; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[workWidth - x, y] = InputMask[x, y]; } } } else if (Method == (int)eMethod.eRightToLeft) { for (int x = 0; x < halfWid; x++) { for (int y = 0; y < parms.Height; y++) { mp.Value[x, y] = InputMask[workWidth - x, y]; } } } else if (Method == (int)eMethod.eTopToBottom) { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < halfHei; y++) { mp.Value[x, y] = InputMask[x, workHeight - y]; } } } else if (Method == (int)eMethod.eBottomToTop) { for (int x = 0; x < parms.Width; x++) { for (int y = 0; y < halfHei; y++) { mp.Value[x, workHeight - y] = InputMask[x, y]; } } } return(true); }