public override void getOutPutVl(IPixelBlock3 pb, System.Array[] inArr, float vl, int c, int r) { float[] orgArr = new float[bndCnt]; float[] sortArr = new float[bndCnt]; orgArr[0] = vl; sortArr[0] = vl; for (int p = 1; p < bndCnt; p++) { float vl2 = System.Convert.ToSingle(inArr[p].GetValue(c, r)); orgArr[p] = vl2; sortArr[p] = vl2; } System.Array.Sort(sortArr); for (int p = 0; p < bndCnt; p++) { rstPixelType ptyp = pb.get_PixelType(p); float orgVl = orgArr[p]; int indexSort = System.Array.LastIndexOf(sortArr, orgVl); float prc = indexSort / bndCntf; object newVl = rasterUtil.getSafeValue(prc, ptyp); inArr[p].SetValue(newVl, c, r); } //int[] cntLst = new int[100]; //float[] probLst = new float[100]; //float[] orgLst = new float[bndCnt]; //int[] indexvl = new int[bndCnt]; //float min = float.MaxValue; //float max = float.MinValue; //float TCnt = 0; //for (int i = 0; i < coefPb.Planes; i++) //{ // object objVl = coefPb.GetVal(i, c, r); // if (objVl != null) // { // float vl = (float)objVl; // orgLst[i] = vl; // if (vl > max) max = vl; // if (vl < min) min = vl; // TCnt+=1; // } //} //float rng = max - min; //for (int i = 0; i < orgLst.Length; i++) //{ // int indexVl = (int)(99*(orgLst[i] - min) / rng); // indexvl[i] = indexVl; // cntLst[indexVl] = cntLst[indexVl] + 1; //} //int sumCnt = 0; //for (int i = 0; i < cntLst.Length; i++) //{ // sumCnt = sumCnt + cntLst[i]; // probLst[i] = sumCnt/TCnt; //} //for (int i = 0; i < orgLst.Length; i++) //{ // updateArr[i].SetValue(probLst[indexvl[i]], c, r); //} }
private object splitArray(int[] vls, IPixelBlock3 pb3) { int width = pb3.Width; int height = pb3.Height; int cnt = 0; System.Array outArr = (System.Array)pb3.get_PixelData(0); rstPixelType rsp = pb3.get_PixelType(0); foreach (int i in vls) { double div = System.Convert.ToDouble(cnt) / width; int r = (int)div; int c = cnt - (r * width); try { object newvl = rasterUtil.getSafeValue(i, rsp); outArr.SetValue(i, c, r); } catch { object newvl = rasterUtil.getSafeValue(900, rsp); outArr.SetValue(900, c, r); } cnt++; } return(outArr); }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { System.Array noDataValueArr = (System.Array)((IRasterProps)pRaster).NoDataValue; myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; IPnt pbBigSize = new PntClass(); IPnt pbBigLoc = new PntClass(); int pbBigWd = pBWidth + clms; int pbBigHt = pBHeight + rws; int l, t; l = (clms - 1) / 2; t = (rws - 1) / 2; //Console.WriteLine("lt = " + (pTlc.X - l).ToString() + ":" + (pTlc.Y - t).ToString()); pbBigSize.SetCoords(pbBigWd, pbBigHt); pbBigLoc.SetCoords((pTlc.X - l), (pTlc.Y - t)); IPixelBlock3 pbBig = (IPixelBlock3)myFunctionHelperOrig.Raster.CreatePixelBlock(pbBigSize); myFunctionHelperOrig.Read(pbBigLoc, null, myFunctionHelperOrig.Raster, (IPixelBlock)pbBig); for (int nBand = 0; nBand < pbBig.Planes; nBand++) { System.Array pixelValues = (System.Array)(ipPixelBlock.get_PixelData(nBand)); rstPixelType rsp = ipPixelBlock.get_PixelType(nBand); //System.Array pixelValuesBig = (System.Array)(pbBig.get_PixelData(nBand)); for (int r = 0; r < pBHeight; r++) { for (int c = 0; c < pBWidth; c++) { object objVl = ipPixelBlock.GetVal(nBand, c, r); if (objVl == null) { continue; } else { float outVl = System.Convert.ToSingle(getTransformedValue(pbBig, c + l, r + t, nBand)); object newVl = rasterUtil.getSafeValue(outVl, rsp); //Console.WriteLine(outVl.ToString()); pixelValues.SetValue(newVl, c, r); } } } ((IPixelBlock3)pPixelBlock).set_PixelData(nBand, pixelValues); } } catch (Exception e) { Console.WriteLine(e.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { //System.Array noDataValueArr = (System.Array)((IRasterProps)pRaster).NoDataValue; myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; IPnt pbBigSize = new PntClass(); IPnt pbBigLoc = new PntClass(); int pbBigWd = pBWidth + clms; int pbBigHt = pBHeight + rws; int l, t; l = clms / 2; t = rws / 2; pbBigSize.SetCoords(pbBigWd, pbBigHt); pbBigLoc.SetCoords((pTlc.X - l), (pTlc.Y - t)); IPixelBlock3 pbBig = (IPixelBlock3)myFunctionHelperOrig.Raster.CreatePixelBlock(pbBigSize); myFunctionHelperOrig.Read(pbBigLoc, null, myFunctionHelperOrig.Raster, (IPixelBlock)pbBig); noDataValue = float.MinValue;//System.Convert.ToSingle(noDataValueArr.GetValue(0)); for (int nBand = 0; nBand < ipPixelBlock.Planes; nBand++) { rstPixelType pbt = ipPixelBlock.get_PixelType(nBand); System.Array pixelValues = (System.Array)(ipPixelBlock.get_PixelData(nBand)); for (int r = 0; r < pBHeight; r++) { for (int c = 0; c < pBWidth; c++) { object inVlobj = ipPixelBlock.GetVal(nBand, c, r); if (inVlobj == null) { continue; } else { updateGLCMDic(pbBig, c, r, nBand); float outVl = System.Convert.ToSingle(getTransformedValue(countDic)); object newVl = rasterUtil.getSafeValue(outVl, pbt); pixelValues.SetValue(newVl, c, r); } } } ((IPixelBlock3)pPixelBlock).set_PixelData(nBand, pixelValues); } } catch (Exception e) { Console.WriteLine(e.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); //System.Windows.Forms.MessageBox.Show("Read resized raster"); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; IPnt pbBigSize = new PntClass(); IPnt pbBigLoc = new PntClass(); int pbBigWd = pBWidth * cells; int pbBigHt = pBHeight * cells; pbBigSize.SetCoords(pbBigWd, pbBigHt); pbBigLoc.SetCoords((pTlc.X * cells), (pTlc.Y * cells)); IPixelBlock pbOrig = myFunctionHelperOrig.Raster.CreatePixelBlock(pbBigSize); //System.Windows.Forms.MessageBox.Show("Read original Raster"); myFunctionHelperOrig.Read(pbBigLoc, null, myFunctionHelperOrig.Raster, pbOrig); IPixelBlock3 pbBig = (IPixelBlock3)pbOrig; //int cnt = 0; for (int nBand = 0; nBand < ipPixelBlock.Planes; nBand++) { //Console.WriteLine(ipPixelBlock.get_PixelType(nBand).ToString()); //object noDataValue = System.Convert.ToSingle(noDataValueArr.GetValue(nBand)); //System.Array pixelValuesBig = (System.Array)(pbBig.get_PixelData(nBand)); rstPixelType pTy = pbBig.get_PixelType(nBand); System.Array pixelValues = (System.Array)(ipPixelBlock.get_PixelData(nBand)); for (int r = 0; r < pBHeight; r++) { for (int c = 0; c < pBWidth; c++) { object objVl = ipPixelBlock.GetVal(nBand, c, r); if (objVl != null) { object outVl = getTransformedValue(pbBig, nBand, c, r, cells); object newVl = rasterUtil.getSafeValue(outVl, pTy); //System.Windows.Forms.MessageBox.Show(outVl.ToString()); pixelValues.SetValue(newVl, c, r); } } } ipPixelBlock.set_PixelData(nBand, pixelValues); } } catch (Exception e) { Console.WriteLine(e.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { // Call Read method of the Raster Function Helper object. myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize); myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; System.Array outArr = (System.Array)ipPixelBlock.get_PixelData(0); rstPixelType pty = ipPixelBlock.get_PixelType(0); double[] vArr = new double[outPb.Planes]; for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { bool checkVl = true; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { object vlObj = outPb.GetVal(0, k, i); if (vlObj == null) { checkVl = false; break; } vArr[coefnBand] = System.Convert.ToDouble(vlObj); } if (checkVl) { double tVl = glm.computeNew(vArr); object newVl = rasterUtil.getSafeValue(tVl, pty); outArr.SetValue(newVl, k, i); } } } ipPixelBlock.set_PixelData(0, outArr); } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of GLM Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { //double vl = 0; //float pixelValue = 0f; try { //System.Array noDataValueArr = (System.Array)((IRasterProps)pRaster).NoDataValue; // Call Read method of the Raster Function Helper object. myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); IPixelBlock3 pb3 = (IPixelBlock3)pPixelBlock; #region Load log object for (int nBand = 0; nBand < pPixelBlock.Planes; nBand++) { //float noDataValue = System.Convert.ToSingle(noDataValueArr.GetValue(nBand)); System.Array dArr = (System.Array)pb3.get_PixelData(nBand); rstPixelType pbT = pb3.get_PixelType(nBand); for (int r = 0; r < pPixelBlock.Height; r++) { for (int c = 0; c < pPixelBlock.Width; c++) { object objVl = pb3.GetVal(nBand, c, r); if (objVl == null) { continue; } else { //vl = System.Convert.ToSingle(objVl); //pixelValue = (float)getFunctionValue(vl); double objVl2 = getFunctionValue(System.Convert.ToDouble(objVl)); object newVl = rasterUtil.getSafeValue(objVl2, pbT); dArr.SetValue(newVl, c, r); } } } pb3.set_PixelData(nBand, dArr); } #endregion } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method math Function. " + exc.Message, exc); throw myExc; } }
private void updateOutArr(IPixelBlock3 outPb, System.Array[] inArr, System.Array outArr) { int bands = inArr.Length; string[] sArr = new string[bands]; System.Array[] vlArr = new System.Array[bands]; rstPixelType pTy = outPb.get_PixelType(0); for (int r = 0; r < outPb.Height; r++) { for (int c = 0; c < outPb.Width; c++) { bool ch = true; for (int p = 0; p < bands; p++) { object inObj = inArr[p].GetValue(c, r); if (inObj == null) { ch = false; break; } else { sArr[p] = inObj.ToString(); } } if (ch) { int vl = uniqueCounter; string sVls = String.Join(",", sArr); if (!uniqueDic.TryGetValue(sVls, out vl)) { uniqueCounter += 1; vl = uniqueCounter; uniqueDic.Add(sVls, vl); } object newVl = rasterUtil.getSafeValue(vl, pTy); outArr.SetValue(newVl, c, r); } } } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampeling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize);//independent variables myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; System.Array[] cArr = new System.Array[ipPixelBlock.Planes]; for (int outBand = 0; outBand < ipPixelBlock.Planes; outBand++) { System.Array pixelValues = (System.Array)ipPixelBlock.get_PixelData(outBand); cArr[outBand] = pixelValues; } for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { double[] expArr = new double[slopes.Length]; double sumExp = 0; int catCnts = 0; bool noDataCheck = true; foreach (double[] IntSlpArr in slopes) { double sumVls = IntSlpArr[0]; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { object coefnVlObj = outPb.GetVal(coefnBand, k, i); //Console.WriteLine("Slope X value = " + pixelValue.ToString()); if (coefnVlObj == null) { noDataCheck = false; break; } double slp = IntSlpArr[coefnBand + 1]; //Console.WriteLine("x = " + pixelValue.ToString() + " slope = " + slp.ToString()); sumVls += System.Convert.ToDouble(coefnVlObj) * slp; } if (noDataCheck) { double expSum = Math.Exp(sumVls); expArr[catCnts] = expSum; sumExp += expSum; catCnts += 1; //Console.WriteLine("sumVls = " + sumVls.ToString()); } else { break; } } if (noDataCheck) { sumExp += 1; double sumProb = 0; catCnts = 1; foreach (double expVl in expArr) { rstPixelType pTy = ipPixelBlock.get_PixelType(catCnts); double prob = expVl / sumExp; //Console.WriteLine("Probability = " + prob.ToString()); sumProb += prob; object newVl = rasterUtil.getSafeValue(prob, pTy); cArr[catCnts].SetValue(newVl, k, i); //Console.WriteLine("Probability = " + cArr[catCnts].GetValue(k,i).ToString()); catCnts += 1; } rstPixelType pTy2 = ipPixelBlock.get_PixelType(0); double lProb = 1 - sumProb; object newVl2 = rasterUtil.getSafeValue(lProb, pTy2); cArr[0].SetValue(newVl2, k, i);//base category } else { for (int b = 0; b < ipPixelBlock.Planes; b++) { cArr[b].SetValue(0, k, i); } } } } for (int i = 0; i < ipPixelBlock.Planes; i++) { ipPixelBlock.set_PixelData(i, cArr[i]); } } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of Regression Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { // Call Read method of the Raster Function Helper object. System.Array noDataValueArr = (System.Array)((IRasterProps)pRaster).NoDataValue; float noDataVl = System.Convert.ToSingle(noDataValueArr.GetValue(0)); myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); noDataValueArr = (System.Array)((IRasterProps)inrsBandsCoef).NoDataValue;//inrsBandsCoef int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize); myFunctionHelper.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; System.Array[] pArr = new System.Array[outPb.Planes]; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { System.Array pixelValues = (System.Array)(outPb.get_PixelData(coefnBand)); pArr[coefnBand] = pixelValues; } for (int nBand = 0; nBand < pPixelBlock.Planes; nBand++) { System.Array outArr = (System.Array)ipPixelBlock.get_PixelData(nBand); rstPixelType pty = ipPixelBlock.get_PixelType(nBand); for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { float[] IntSlpArr = slopes[nBand]; double sumVls = IntSlpArr[0]; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { double noDataValue = System.Convert.ToDouble(noDataValueArr.GetValue(coefnBand)); double pixelValue = Convert.ToDouble(pArr[coefnBand].GetValue(k, i)); if (rasterUtil.isNullData(pixelValue, noDataValue)) { sumVls = noDataVl; break; } double slp = System.Convert.ToDouble(IntSlpArr[coefnBand + 1]); sumVls += pixelValue * slp; } if (sumVls < censored) { sumVls = censored; } object newVl = rasterUtil.getSafeValue(sumVls, pty); outArr.SetValue(newVl, k, i); } } ipPixelBlock.set_PixelData(nBand, outArr); } } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of Tobit Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { // Call Read method of the Raster Function Helper object. myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); //noDataValueArr = (System.Array)((IRasterProps)inrsBandsCoef).NoDataValue;//inrsBandsCoef int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize); myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; //System.Array[] pArr = new System.Array[outPb.Planes]; //for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) //{ // System.Array pixelValues = (System.Array)(outPb.get_PixelData(coefnBand)); // pArr[coefnBand] = pixelValues; //} for (int nBand = 0; nBand < pPixelBlock.Planes; nBand++) { System.Array outArr = (System.Array)ipPixelBlock.get_PixelData(nBand); rstPixelType pty = ipPixelBlock.get_PixelType(nBand); for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { float[] IntSlpArr = slopes[nBand]; double sumVls = IntSlpArr[0]; bool checkNoData = true; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { double slp = System.Convert.ToDouble(IntSlpArr[coefnBand + 1]); if (slp == 0) { continue; } //double noDataValue = System.Convert.ToDouble(noDataValueArr.GetValue(coefnBand)); object objPvl = outPb.GetVal(coefnBand, k, i); if (objPvl == null) { checkNoData = false; break; } else { double pixelValue = Convert.ToDouble(objPvl); sumVls += pixelValue * slp; } } if (checkNoData) { object nVl = rasterUtil.getSafeValue(sumVls, pty); outArr.SetValue(nVl, k, i); } } } ipPixelBlock.set_PixelData(nBand, outArr); } } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of Tobit Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize);//independent variables myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; System.Array[] cArr = new System.Array[ipPixelBlock.Planes]; for (int outBand = 0; outBand < ipPixelBlock.Planes; outBand++) { System.Array pixelValues = (System.Array)ipPixelBlock.get_PixelData(outBand);//(System.Array)(td); cArr[outBand] = pixelValues; } for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { bool ndT = true; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { object pObj = outPb.GetVal(coefnBand, k, i); if (pObj == null) { ndT = false; break; } double pixelValue = Convert.ToDouble(pObj); xVls[coefnBand] = pixelValue; } if (ndT) { try { double[] pp = lm.computNew(xVls); for (int p = 0; p < pp.Length; p++) { double pVl = pp[p]; object spVl = rasterUtil.getSafeValue(pVl, ipPixelBlock.get_PixelType(p)); cArr[p].SetValue(spVl, k, i); } } catch (Exception e) { Console.WriteLine(e.ToString()); for (int p = 0; p < ipPixelBlock.Planes; p++) { cArr[p].SetValue(0, k, i); } } } else { for (int p = 0; p < ipPixelBlock.Planes; p++) { cArr[p].SetValue(0, k, i); } } } } for (int i = 0; i < ipPixelBlock.Planes; i++) { ipPixelBlock.set_PixelData(i, cArr[i]); } } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of Regression Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// 写入栅格数据。 /// </summary> public static void WriteRaster(IRasterLayer rasterLayer, float[,] datas) { int columnCount = rasterLayer.ColumnCount; int rowCount = rasterLayer.RowCount; IRaster2 raster = rasterLayer.Raster as IRaster2; IPnt fromPnt = new PntClass(); fromPnt.SetCoords(0, 0); IPnt blockSize = new PntClass(); blockSize.SetCoords(columnCount, rowCount); IPixelBlock pixelBlock = ((IRaster)raster).CreatePixelBlock(blockSize); rasterLayer.Raster.Read(fromPnt, pixelBlock); IPixelBlock3 pixelBlock3 = (IPixelBlock3)pixelBlock; object temp = pixelBlock3.get_PixelDataByRef(0); if ((pixelBlock3.get_PixelType(0) == rstPixelType.PT_CLONG) || (pixelBlock3.get_PixelType(0) == rstPixelType.PT_ULONG)) { System.Int32[,] pixelData = (System.Int32[, ])temp; for (int i = 0; i < rowCount; i++) { for (int j = 0; j < columnCount; j++) { if (datas[i, j] == -9999f) { pixelData[j, i] = 0; } else { if (pixelData[j, i] != Convert.ToInt32(datas[i, j])) { pixelData[j, i] = Convert.ToInt32(datas[i, j]); } } } } pixelBlock3.set_PixelData(0, pixelData); } else if ((pixelBlock3.get_PixelType(0) == rstPixelType.PT_SHORT) || (pixelBlock3.get_PixelType(0) == rstPixelType.PT_USHORT)) { System.Int16[,] pixelData = (System.Int16[, ])temp; for (int i = 0; i < rowCount; i++) { for (int j = 0; j < columnCount; j++) { if (datas[i, j] == -9999f) { pixelData[j, i] = 0; } else { if (pixelData[j, i] != Convert.ToInt16(datas[i, j])) { pixelData[j, i] = Convert.ToInt16(datas[i, j]); } } } } pixelBlock3.set_PixelData(0, pixelData); } else if ((pixelBlock3.get_PixelType(0) == rstPixelType.PT_CHAR) || (pixelBlock3.get_PixelType(0) == rstPixelType.PT_UCHAR)) { System.Byte[,] pixelData = (System.Byte[, ])temp; for (int i = 0; i < rowCount; i++) { for (int j = 0; j < columnCount; j++) { if (datas[i, j] == -9999f) { //pixelData[j, i] = 0; ; } else { if (pixelData[j, i] != Convert.ToByte(datas[i, j])) { pixelData[j, i] = Convert.ToByte(datas[i, j]); } } } } pixelBlock3.set_PixelData(0, pixelData); } else if (pixelBlock3.get_PixelType(0) == rstPixelType.PT_FLOAT) { System.Single[,] pixelData = (System.Single[, ])temp; for (int i = 0; i < rowCount; i++) { for (int j = 0; j < columnCount; j++) { if (datas[i, j] == -9999f) { //pixelData[j, i] =0; ; } else { if (pixelData[j, i] != Convert.ToSingle(datas[i, j])) { pixelData[j, i] = Convert.ToSingle(datas[i, j]); } } } } pixelBlock3.set_PixelData(0, pixelData); } ((IRasterEdit)rasterLayer.Raster).Write(fromPnt, (IPixelBlock)pixelBlock3); ((IRasterEdit)rasterLayer.Raster).Refresh(); }
private object splitArray(int[] vls, IPixelBlock3 pb3) { int width = pb3.Width; int height = pb3.Height; int cnt = 0; System.Array outArr = (System.Array)pb3.get_PixelData(0); rstPixelType rsp = pb3.get_PixelType(0); foreach (int i in vls) { double div = System.Convert.ToDouble(cnt) / width; int r = (int)div; int c = cnt - (r * width); try { object newvl = rasterUtil.getSafeValue(i, rsp); outArr.SetValue(i, c, r); } catch { object newvl = rasterUtil.getSafeValue(900, rsp); outArr.SetValue(900, c, r); } cnt++; } return outArr; }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { // Call Read method of the Raster Function Helper object. //System.Array noDataValueArr = (System.Array)((IRasterProps)inrsBandsCoef).NoDataValue; //Console.WriteLine("Before Read"); myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); //Console.WriteLine("After Read"); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize);//independent variables myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; System.Array[] pArr = new System.Array[ipPixelBlock.Planes]; for (int coefnBand = 0; coefnBand < ipPixelBlock.Planes; coefnBand++) { System.Array pixelValues = (System.Array)(pPixelBlock.get_SafeArray(coefnBand)); pArr[coefnBand] = pixelValues; } for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { object pObj = outPb.GetVal(0, k, i); if (pObj == null) { continue; } else { string pixelValue = pObj.ToString(); double[] c; if (tDic.TryGetValue(pixelValue, out c)) { for (int v = 0; v < pArr.Length; v++) { double vl = c[v]; object newVl = rasterUtil.getSafeValue(vl, ipPixelBlock.get_PixelType(v)); pArr[v].SetValue(newVl, k, i); } } else { for (int v = 0; v < pArr.Length; v++) { pArr.SetValue(ndVl, k, i); } } } } } for (int i = 0; i < pArr.Length; i++) { ipPixelBlock.set_PixelData(i, pArr[i]); } } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of TTest Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { // Call Read method of the Raster Function Helper object. //System.Array noDataValueArr = (System.Array)((IRasterProps)inrsBandsCoef).NoDataValue; //Console.WriteLine("Before Read"); myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); //Console.WriteLine("After Read"); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize);//independent variables myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; //System.Array[] pArr = new System.Array[outPb.Planes]; //for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) //{ // System.Array pixelValues = (System.Array)(outPb.get_PixelData(coefnBand)); // pArr[coefnBand] = pixelValues; //} System.Array pValues = (System.Array)ipPixelBlock.get_PixelData(0);//(System.Array)(td); rstPixelType pTyp = ipPixelBlock.get_PixelType(0); for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { double[] xVls = new double[outPb.Planes]; bool ndT = true; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { //float noDataValue = System.Convert.ToSingle(noDataValueArr.GetValue(coefnBand)); object pObj = outPb.GetVal(coefnBand, k, i); if (pObj == null) { ndT = false; break; } double pixelValue = Convert.ToDouble(pObj); xVls[coefnBand] = pixelValue; } if (ndT) { int c = cluster.computNew(xVls); object newVl = rasterUtil.getSafeValue(c, pTyp); pValues.SetValue(newVl, k, i); } } } ipPixelBlock.set_PixelData(0, pValues); } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of Cluster Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }
/// <summary> /// Read pixels from the input Raster and fill the PixelBlock provided with processed pixels. /// The RasterFunctionHelper object is used to handle pixel type conversion and resampling. /// The log raster is the natural log of the raster. /// </summary> /// <param name="pTlc">Point to start the reading from in the Raster</param> /// <param name="pRaster">Reference Raster for the PixelBlock</param> /// <param name="pPixelBlock">PixelBlock to be filled in</param> public void Read(IPnt pTlc, IRaster pRaster, IPixelBlock pPixelBlock) { try { // Call Read method of the Raster Function Helper object. myFunctionHelper.Read(pTlc, null, pRaster, pPixelBlock); int pBHeight = pPixelBlock.Height; int pBWidth = pPixelBlock.Width; IPnt pbSize = new PntClass(); pbSize.SetCoords(pBWidth, pBHeight); IPixelBlock3 outPb = (IPixelBlock3)myFunctionHelperCoef.Raster.CreatePixelBlock(pbSize); myFunctionHelperCoef.Read(pTlc, null, myFunctionHelperCoef.Raster, (IPixelBlock)outPb); int pBRowIndex = 0; int pBColIndex = 0; IPixelBlock3 ipPixelBlock = (IPixelBlock3)pPixelBlock; for (int nBand = 0; nBand < pPixelBlock.Planes; nBand++) { System.Array outArr = (System.Array)ipPixelBlock.get_PixelData(nBand); rstPixelType pty = ipPixelBlock.get_PixelType(nBand); for (int i = pBRowIndex; i < pBHeight; i++) { for (int k = pBColIndex; k < pBWidth; k++) { bool checkNoData = true; int ov = 1; for (int coefnBand = 0; coefnBand < outPb.Planes; coefnBand++) { double min = mins[coefnBand]; double max = maxs[coefnBand]; object objPvl = outPb.GetVal(coefnBand, k, i); if (objPvl == null) { checkNoData = false; ov = 0; break; } else { double pixelValue = Convert.ToDouble(objPvl); if (pixelValue < min || pixelValue > max) { ov = 0; break; } } } if (checkNoData) { object nVl = rasterUtil.getSafeValue(ov, pty); outArr.SetValue(nVl, k, i); } } } ipPixelBlock.set_PixelData(nBand, outArr); } } catch (Exception exc) { System.Exception myExc = new System.Exception("Exception caught in Read method of Domain Function. " + exc.Message, exc); Console.WriteLine(exc.ToString()); } }