public void Bind(object pArgument)
 {
     if (pArgument is glcmFunctionArguments)
     {
         glcmFunctionArguments args = (glcmFunctionArguments)pArgument;
         inrs = args.InRaster;
         orig = args.OriginalRaster;
         inWindow = args.WindowType;
         iter = args.GenericIterator;
         clms = args.Columns;
         rws = args.Rows;
         radius = args.Radius;
         glcmMetrics = args.GLCMMETRICS;
         horizontal = args.Horizontal;
         myFunctionHelper.Bind(inrs);
         myFunctionHelperOrig.Bind(orig);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: glcmFunctonArguments");
     }
 }
Ejemplo n.º 2
0
 public void Bind(object pArgument)
 {
     if (pArgument is FocalFunctionArguments)
     {
         FocalFunctionArguments args = (FocalFunctionArguments)pArgument;
         inrs     = args.InRaster;
         orig     = args.OriginalRaster;
         inop     = args.Operation;
         inWindow = args.WindowType;
         lsiter   = args.Fastiter;
         windowN  = args.WindowCount;
         //Console.WriteLine(lsiter.Count());
         clms   = args.Columns;
         rws    = args.Rows;
         radius = args.Radius;
         myFunctionHelper.Bind(inrs);
         myFunctionHelperOrig.Bind(orig);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype  = myRasterInfo.PixelType;
         myValidFlag  = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: FocalFunctonArguments");
     }
 }
Ejemplo n.º 3
0
        public bool checkCellSize()
        {
            bool   cS   = true;
            IPnt   zPnt = zRs.RasterInfo.CellSize;
            IPnt   vPnt = vRs.RasterInfo.CellSize;
            double zX   = zPnt.X;
            double zY   = zPnt.Y;
            double vX   = vPnt.X;
            double vY   = vPnt.Y;
            double ns   = vX;

            if (Math.Abs(vX - vY) > 0.0001)
            {
                if (vY < vX)
                {
                    ns = vY;
                }
                InValueRaster = rsUtil.reSampleRasterFunction(vRs, ns);
                if (rd != null)
                {
                    rd.addMessage("Value dataset cells Width and Height are not the same! Resizing the valueRaster cell width and height to " + ns.ToString() + "!");
                }
            }
            if (Math.Abs(zX - ns) > 0.0001)
            {
                InZoneRaster = rsUtil.reSampleRasterFunction(zRs, ns);
                if (rd != null)
                {
                    rd.addMessage("Zone and value dataset cells are not the same size! Resizing the zoneRaster cell width and height to match the value raster (" + vRs.RasterInfo.CellSize.X.ToString() + ":" + zRs.RasterInfo.CellSize.X.ToString() + ")!");
                }
            }
            return(cS);
        }
Ejemplo n.º 4
0
 private void populateComboBox()
 {
     if (mp != null)
     {
         foreach (KeyValuePair <string, IFeatureClass> kvp in ftrDic)
         {
             IFeatureClass ftrCls = kvp.Value;
             string        nm     = kvp.Key;
             if (ftrCls.ShapeType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint || ftrCls.ShapeType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultipoint)
             {
                 cmbSampleFeatureClass.Items.Add(nm);
             }
             if (ftrCls.ShapeType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon)
             {
                 cmbRaster.Items.Add(nm);
             }
         }
         foreach (KeyValuePair <string, IFunctionRasterDataset> kvp in rstDic)
         {
             IFunctionRasterDataset rsDet = kvp.Value;
             string nm = kvp.Key;
             cmbRaster.Items.Add(nm);
         }
     }
 }
Ejemplo n.º 5
0
 public void Bind(object pArgument)
 {
     if (pArgument is glcmFunctionArguments)
     {
         glcmFunctionArguments args = (glcmFunctionArguments)pArgument;
         inrs        = args.InRaster;
         orig        = args.OriginalRaster;
         inWindow    = args.WindowType;
         iter        = args.GenericIterator;
         clms        = args.Columns;
         rws         = args.Rows;
         radius      = args.Radius;
         glcmMetrics = args.GLCMMETRICS;
         horizontal  = args.Horizontal;
         myFunctionHelper.Bind(inrs);
         myFunctionHelperOrig.Bind(orig);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype  = myRasterInfo.PixelType;
         myValidFlag  = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: glcmFunctonArguments");
     }
 }
Ejemplo n.º 6
0
        /// <summary>
        /// Each BuilderItem contains a Function Raster Dataset which is used to create the thumbnail.
        /// The thumbnail is created by Nearest Neighbor resampling of the Function Raster Dataset.
        /// The resampled raster is exported as a byte array and saved Into the IMemoryBlobStreamVariant.
        /// The blob is then inserted into the Thumbnail field.
        /// </summary>
        /// <param name="mybuilderItem">Item containing the Function Dataset to be added to the Mosaic Dataset</param>
        private void Resampling(IBuilderItem mybuilderItem)
        {
            try
            {
                IFunctionRasterDataset pFuncRasterDataset = mybuilderItem.Dataset; // Get the FunctionRasterDataset from mybuilderItem
                IRasterDataset         pRasterDataset;
                pRasterDataset = (IRasterDataset)pFuncRasterDataset;               // Cast the FunctionRasterDataset to Raster Dataset
                IPropertySet thePropSet = pFuncRasterDataset.Properties;           // Get the properties of the raster Dataset
                IRaster      praster    = pRasterDataset.CreateDefaultRaster();    // Create default raster from the above raster dataset
                praster.ResampleMethod = rstResamplingTypes.RSP_NearestNeighbor;   // The raster is resampled by RSP_NearestNeighbor
                IRasterProps pRasterProps = (IRasterProps)praster;                 // Raster properties are used to update the height, width of the raster
                pRasterProps.Height = 256;
                pRasterProps.Width  = 256;

                IRasterExporter pConverter = new RasterExporterClass();                           // IRasterExporter object is used to convert the raster to byte array.
                byte[]          pBytesArr;
                pBytesArr = pConverter.ExportToBytes(praster, "TIFF");                            // Convert the resampled Raster to a Byte array
                IMemoryBlobStream        memBlobStream = new MemoryBlobStream();                  // Create new IMemoryBlobStream
                IMemoryBlobStreamVariant varBlobStream = (IMemoryBlobStreamVariant)memBlobStream; // Assign to IMemoryBlobStreamVariant
                object anObject = pBytesArr;
                varBlobStream.ImportFromVariant(anObject);                                        // IMemoryBlobStreamVariant object is assigned the byte array
                thePropSet.SetProperty("ThumbNail", memBlobStream);                               // and saved to the property "ThumbNail"
            }
            catch (Exception ex)
            {
                System.Exception myExc = new System.Exception(
                    "Error: Failed to Re-Sampled the raster.Thumbnails will not be created." + ex.Message, ex);
                throw myExc;
            }
            return;
        }
Ejemplo n.º 7
0
        private void button1_Click(object sender, EventArgs e)
        {
            OpenFileDialog od = new OpenFileDialog();

            od.Filter      = "Net CDF|*.nc";
            od.Multiselect = true;
            if (od.ShowDialog() == DialogResult.OK)
            {
                FrmNecCdfAttributeSelection frmAt = new FrmNecCdfAttributeSelection(od.FileNames[0], rsUtil);
                frmAt.ShowDialog();
                foreach (string fn in od.FileNames)
                {
                    //System.Windows.Forms.MessageBox.Show(fn);
                    string outName = System.IO.Path.GetFileNameWithoutExtension(fn);
                    if (!rstDic.ContainsKey(outName))
                    {
                        //string vls = frmAt.variable + ", " + frmAt.xdim + ", " + frmAt.ydim + ", " + frmAt.bands;
                        IFunctionRasterDataset rsA = rsUtil.returnFunctionRasterDatasetNetCDF(fn, frmAt.variable, frmAt.xdim, frmAt.ydim, frmAt.bands);
                        //System.Windows.Forms.MessageBox.Show(((IRasterBandCollection)rsA).Count.ToString() + "; " + vls);
                        rstDic.Add(outName, rsA);
                        //cmbInRaster1.Items.Add(outName);
                        lsbRaster.Items.Add(outName);
                    }
                    else
                    {
                        IFunctionRasterDataset rsA = rsUtil.returnFunctionRasterDatasetNetCDF(fn, frmAt.variable, frmAt.xdim, frmAt.ydim, frmAt.bands);
                        rstDic[outName] = rsA;
                        //System.Windows.Forms.MessageBox.Show(((IRasterBandCollection)rsA).Count.ToString());
                    }
                }
                frmAt.Close();
                frmAt.Dispose();
            }
        }
Ejemplo n.º 8
0
        public normalization(IFunctionRasterDataset ReferenceRaster, IFunctionRasterDataset TransformRaster, int PercentChange = 20, rasterUtil rasterUtility = null)
        {
            referenceRaster = ReferenceRaster;
            IRasterBandCollection rsBc = (IRasterBandCollection)referenceRaster;

            rsType         = referenceRaster.RasterInfo.PixelType;
            cellCount      = new int[rsBc.Count];
            minArray       = new double[rsBc.Count];
            maxArray       = new double[rsBc.Count];
            sumX2Array     = new double[rsBc.Count];
            sumXArray      = new double[rsBc.Count];
            sumXYArray     = new double[rsBc.Count];
            sumYArray      = new double[rsBc.Count];
            sumY2Array     = new double[rsBc.Count];
            coef           = new double[rsBc.Count][];
            blockCellCount = new int[rsBc.Count];
            difDic         = new Dictionary <int, int> [rsBc.Count];
            for (int i = 0; i < rsBc.Count; i++)
            {
                difDic[i] = new Dictionary <int, int>();
            }
            transformRaster = TransformRaster;
            pChange         = System.Convert.ToDouble(PercentChange) / 200d;
            rsUtil          = rasterUtility;
        }
Ejemplo n.º 9
0
 private void populateComboBox()
 {
     if (mp != null)
     {
         IEnumLayer rstLyrs = vUtil.getActiveViewLayers(viewUtility.esriIRasterLayer);
         ILayer     lyr     = rstLyrs.Next();
         while (lyr != null)
         {
             string                 lyrNm  = lyr.Name;
             IRasterLayer           rstLyr = (IRasterLayer)lyr;
             IFunctionRasterDataset rst    = rsUtil.createIdentityRaster(((IRaster2)rstLyr.Raster).RasterDataset);
             if (!rstDic.ContainsKey(lyrNm))
             {
                 rstDic.Add(lyrNm, rst);
                 cmbInRaster1.Items.Add(lyrNm);
             }
             lyr = rstLyrs.Next();
         }
     }
     foreach (string s in Enum.GetNames(typeof(rasterUtil.localType)))
     {
         cmbFunction.Items.Add(s);
     }
     cmbFunction.SelectedItem = rasterUtil.localType.MEAN.ToString();
 }
 public void Bind(object pArgument)
 {
     if (pArgument is FocalFunctionArguments)
     {
         FocalFunctionArguments args = (FocalFunctionArguments)pArgument;
         inrs = args.InRaster;
         orig = args.OriginalRaster;
         inop = args.Operation;
         inWindow = args.WindowType;
         lsiter = args.Fastiter;
         windowN = args.WindowCount;
         //Console.WriteLine(lsiter.Count());
         clms = args.Columns;
         rws = args.Rows;
         radius = args.Radius;
         myFunctionHelper.Bind(inrs);
         myFunctionHelperOrig.Bind(orig);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: FocalFunctonArguments");
     }
 }
        public void Bind(object pArgument)
        {
            if (pArgument is combineFunctionArguments)
            {
                combineFunctionArguments args = (combineFunctionArguments)pArgument;

                inrs = args.InRasterDataset;
                outRs = args.OutRaster;
                myFunctionHelper.Bind(outRs);
                //myFunctionHelperCoef.Bind(inrs);
                myRasterInfo = myFunctionHelper.RasterInfo;
                myPixeltype = myRasterInfo.PixelType;
                myValidFlag = true;
                object tnd = myRasterInfo.NoData;
                if(tnd==null)
                {
                }
                else
                {
                    noDataVl = ((System.Array)myRasterInfo.NoData).GetValue(0);
                }

            }
            else
            {
                throw new System.Exception("Incorrect arguments object. Expected: combineFunctonArguments");
            }
        }
Ejemplo n.º 12
0
        private IFunctionRasterDataset calcCorr()
        {
            //Cov
            double N = (SumRws * SumClms * 2);
            IFunctionRasterDataset mvRst = getShiftedRaster(InRaster);
            IFunctionRasterDataset pRs   = rsUtil.calcArithmaticFunction(InRaster, mvRst, esriRasterArithmeticOperation.esriRasterPlus);
            IFunctionRasterDataset pRs2T = rsUtil.calcArithmaticFunction(InRaster, mvRst, esriRasterArithmeticOperation.esriRasterMultiply);
            IFunctionRasterDataset pRs2  = rsUtil.calcArithmaticFunction(pRs2T, 2, esriRasterArithmeticOperation.esriRasterMultiply);
            IFunctionRasterDataset mRsT  = rsUtil.calcFocalStatisticsFunction(pRs, SumClms, SumRws, rasterUtil.focalType.SUM);
            IFunctionRasterDataset mRsT2 = rsUtil.calcArithmaticFunction(mRsT, 2, esriRasterArithmeticOperation.esriRasterPower);
            IFunctionRasterDataset mRs   = rsUtil.calcArithmaticFunction(mRsT2, N, esriRasterArithmeticOperation.esriRasterDivide);
            IFunctionRasterDataset mRs2  = rsUtil.calcFocalStatisticsFunction(pRs2, SumClms, SumRws, rasterUtil.focalType.SUM);
            IFunctionRasterDataset cov   = rsUtil.calcArithmaticFunction(mRs2, mRs, esriRasterArithmeticOperation.esriRasterMinus);
            //IRaster cov2 = RasterUtility.calcEqualFunction(cov1, 0);
            //IRaster cov = RasterUtility.calcArithmaticFunction(cov2, cov1, esriRasterArithmeticOperation.esriRasterPlus);
            //Var
            IFunctionRasterDataset x2     = rsUtil.calcArithmaticFunction(InRaster, 2, esriRasterArithmeticOperation.esriRasterPower);
            IFunctionRasterDataset mvRst2 = getShiftedRaster(x2);

            pRs2 = rsUtil.calcArithmaticFunction(x2, mvRst2, esriRasterArithmeticOperation.esriRasterPlus);
            mRs2 = rsUtil.calcFocalStatisticsFunction(pRs2, SumClms, SumRws, rasterUtil.focalType.SUM);
            IFunctionRasterDataset var = rsUtil.calcArithmaticFunction(mRs2, mRs, esriRasterArithmeticOperation.esriRasterMinus);
            //IRaster var2 = RasterUtility.calcEqualFunction(var1, 0);
            //IRaster var = RasterUtility.calcArithmaticFunction(var2, var1, esriRasterArithmeticOperation.esriRasterPlus);
            IFunctionRasterDataset cor = rsUtil.calcArithmaticFunction(cov, var, esriRasterArithmeticOperation.esriRasterDivide);

            return(RasterUtility.setnullToValueFunction(cor, 1));
        }
Ejemplo n.º 13
0
        public void Bind(object pArgument)
        {
            if (pArgument is combineFunctionArguments)
            {
                combineFunctionArguments args = (combineFunctionArguments)pArgument;

                inrs  = args.InRasterDataset;
                outRs = args.OutRaster;
                myFunctionHelper.Bind(outRs);
                //myFunctionHelperCoef.Bind(inrs);
                myRasterInfo = myFunctionHelper.RasterInfo;
                myPixeltype  = myRasterInfo.PixelType;
                myValidFlag  = true;
                object tnd = myRasterInfo.NoData;
                if (tnd == null)
                {
                }
                else
                {
                    noDataVl = ((System.Array)myRasterInfo.NoData).GetValue(0);
                }
            }
            else
            {
                throw new System.Exception("Incorrect arguments object. Expected: combineFunctonArguments");
            }
        }
Ejemplo n.º 14
0
        //public IFeatureClass createPolygons3()
        //{
        //    createFeatureClass();

        //}
        public IFeatureClass createPolygons2()
        {
            createFeatureClass();
            IRasterProps           rsProp   = (IRasterProps)inputRaster;
            int                    bndCnt   = ((IRasterBandCollection)inputRaster).Count;
            IPnt                   rsPnt    = rsProp.MeanCellSize();
            double                 cellArea = rsPnt.X * rsPnt.Y;
            double                 tCells   = minArea / cellArea;
            IFunctionRasterDataset sDset    = rsUtil.createMeanShiftFuction(inputRaster, (int)tCells);

            FunctionRasters.meanShiftFunctionDataset rFunc = (FunctionRasters.meanShiftFunctionDataset)sDset.Function;
            IRaster2               rs2   = (IRaster2)rsUtil.createRaster(sDset);
            IRasterCursor          rsCur = rs2.CreateCursorEx(null);
            IRasterDomainExtractor dExt  = new RasterDomainExtractorClass();

            do
            {
                IPixelBlock            pb     = rsCur.PixelBlock;
                IFunctionRasterDataset pbDset = rsUtil.PixelBlockToRaster(pb, rsCur.TopLeft, sDset);
                IRaster rs          = rsUtil.createRaster(pbDset);
                int     numClusters = rFunc.NumClusters;
                for (int c = 0; c < numClusters; c++)
                {
                    IFunctionRasterDataset fd  = rsUtil.calcEqualFunction(pbDset, c);
                    IFunctionRasterDataset fd2 = rsUtil.setNullValue(fd, 0);
                    IPolygon polys             = dExt.ExtractDomain(rsUtil.createRaster(fd2), true);
                }
            } while (rsCur.Next() == true);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(rsCur);



            return(outftr);
        }
Ejemplo n.º 15
0
 public TransRouting(IWorkspace outworkspace, IFunctionRasterDataset DEM, SpeedUnits spUnits = SpeedUnits.KPH)
 {
     Dem          = DEM;
     sp           = DEM.RasterInfo.SpatialReference;
     OutWorkspace = outworkspace;
     Units        = spUnits;
     getConversionFactor();
 }
Ejemplo n.º 16
0
        private IFunctionRasterDataset calcContrast()
        {
            IFunctionRasterDataset mvRst = getShiftedRaster(InRaster);
            IFunctionRasterDataset difRs = rsUtil.calcArithmaticFunction(InRaster, mvRst, esriRasterArithmeticOperation.esriRasterMinus);
            IFunctionRasterDataset dif2  = rsUtil.calcArithmaticFunction(difRs, 2, esriRasterArithmeticOperation.esriRasterPower);

            return(rsUtil.calcFocalStatisticsFunction(dif2, SumClms, SumRws, rasterUtil.focalType.MEAN));
        }
Ejemplo n.º 17
0
 public void addRasterToComboBox(string rstName, IFunctionRasterDataset rst)
 {
     if (!cmbInRaster1.Items.Contains(rstName))
     {
         cmbInRaster1.Items.Add(rstName);
         rstDic[rstName] = rst;
     }
 }
Ejemplo n.º 18
0
        private IFunctionRasterDataset calcAgFunction(IFunctionRasterDataset rr, string outName, int numCells)
        {
            IFunctionRasterDataset sumRs = rsUtil.calcAggregationFunction(rr, numCells, rasterUtil.focalType.SUM);
            IWorkspace             sWks  = geoUtil.OpenRasterWorkspace(sedDir);
            IRasterDataset         rsD   = rsUtil.saveRasterToDataset(rsUtil.createRaster(sumRs), outName, sWks, rasterUtil.rasterType.IMAGINE);

            return(rsUtil.createIdentityRaster(rsD));
        }
Ejemplo n.º 19
0
        private IFunctionRasterDataset calcMean()
        {
            IFunctionRasterDataset mvRst = getShiftedRaster(InRaster);
            IFunctionRasterDataset pRs   = rsUtil.calcArithmaticFunction(InRaster, mvRst, esriRasterArithmeticOperation.esriRasterPlus);
            IFunctionRasterDataset mRs   = rsUtil.calcFocalStatisticsFunction(pRs, SumClms, SumRws, rasterUtil.focalType.MEAN);

            return(rsUtil.calcArithmaticFunction(mRs, 2, esriRasterArithmeticOperation.esriRasterDivide));
        }
Ejemplo n.º 20
0
        public void convertFeatureToRaster(IFeatureClass InFeatureClass, string fldName)
        {
            ftrCls   = InFeatureClass;
            ftrField = fldName;
            IDataset dSet    = (IDataset)InFeatureClass;
            string   outRsNm = dSet.BrowseName;

            wks = dSet.Workspace;
            if (vRs != null)
            {
                if (!checkProjectionsFtr())
                {
                    if (rd != null)
                    {
                        rd.addMessage("Re-projecting feature class to match value raster's projection");
                    }
                    InFeatureClass = reprojectInFeatureClass(InFeatureClass, vRs.RasterInfo.SpatialReference);
                }
            }
            IWorkspace             wksTemp = geoUtil.OpenRasterWorkspace(tempWksStr);
            IFunctionRasterDataset rs      = rsUtil.createIdentityRaster(rsUtil.convertFeatureClassToRaster(InFeatureClass, rasterUtil.rasterType.IMAGINE, wksTemp, outRsNm, vRs.RasterInfo.CellSize.X, (IRasterDataset)vRs));

            rs = rsUtil.createIdentityRaster(rs, rstPixelType.PT_FLOAT);
            int fieldIndex = InFeatureClass.FindField(fldName);

            if (fieldIndex == -1)
            {
                fieldIndex = InFeatureClass.FindField(fldName + "_1");
            }
            if (fldName.ToLower() == InFeatureClass.OIDFieldName.ToLower() || fieldIndex == -1)
            {
                zRs = rs;
            }
            else
            {
                IRemapFilter   rFilt  = new RemapFilterClass();
                IFeatureCursor ftrCur = InFeatureClass.Search(null, false);
                IFeature       ftr    = ftrCur.NextFeature();

                while (ftr != null)
                {
                    double id  = ftr.OID;
                    double nVl = System.Convert.ToDouble(ftr.get_Value(fieldIndex));
                    if (Double.IsNaN(nVl) || Double.IsInfinity(nVl))
                    {
                        ftr = ftrCur.NextFeature();
                    }
                    else
                    {
                        //Console.WriteLine("adding oid = " + id.ToString() + " and value = " + nVl.ToString());
                        rFilt.AddClass(id, id + 1, nVl);
                        ftr = ftrCur.NextFeature();
                    }
                }
                zRs = rsUtil.calcRemapFunction(rs, rFilt);
            }
        }
Ejemplo n.º 21
0
        private void setInRs()
        {
            IEnvelope env = new EnvelopeClass();
            double    mx, my;
            IRaster2  rs       = (IRaster2)rsUtil.createRaster(valueraster);
            IPnt      cellSize = valueraster.RasterInfo.CellSize;

            rs.PixelToMap((int)topleft.X, (int)topleft.Y, out mx, out my);
            env.PutCoords(mx, my - (cellSize.Y * vpixelBlock.Height), mx + (cellSize.X * vpixelBlock.Width), my);
            inrs = rsUtil.constantRasterFunction((IRaster)rs, env, 0, cellSize);
        }
Ejemplo n.º 22
0
        private void buildPathRasters()
        {
            getSpatialAnalystLicense();
            if (FunctionAccumulatedPathAllocation == null)
            {
                buildPathAllocation();
            }
            //calculate costs
            IFunctionRasterDataset onRdCs  = null;
            IFunctionRasterDataset offRdCs = null;

            if (OnRoadMachineRateRaster == null)
            {
                float dollarPerTonConv = (OnRoadMachineRate / onRoadPayLoad) * 0.001f;// * 1000;
                onRdCs = rsUtil.calcArithmaticFunction(FunctionAccumulatedPathAllocation, dollarPerTonConv, esriRasterArithmeticOperation.esriRasterMultiply);
            }
            else
            {
                IFunctionRasterDataset dollarPerTonConv = rsUtil.calcArithmaticFunction(OnRoadMachineRateRaster, onRoadPayLoad * 1000f, esriRasterArithmeticOperation.esriRasterDivide);
                onRdCs = rsUtil.calcArithmaticFunction(FunctionAccumulatedPathAllocation, dollarPerTonConv, esriRasterArithmeticOperation.esriRasterMultiply);
            }
            if (OffRoadMachineRateRaster == null)
            {
                float offDollarPerTonConv = (OffRoadMachineRate / OffRoadPayLoad);
                offRdCs = rsUtil.calcArithmaticFunction(FunctionAccumulatedFromPathDistance, offDollarPerTonConv, esriRasterArithmeticOperation.esriRasterMultiply);
            }
            else
            {
                IFunctionRasterDataset offDollarPerTonConv = rsUtil.calcArithmaticFunction(OffRoadMachineRateRaster, OffRoadPayLoad, esriRasterArithmeticOperation.esriRasterDivide);
                offRdCs = rsUtil.calcArithmaticFunction(FunctionAccumulatedFromPathDistance, offDollarPerTonConv, esriRasterArithmeticOperation.esriRasterMultiply);
            }
            IFunctionRasterDataset t0        = rsUtil.calcArithmaticFunction(onRdCs, offRdCs, esriRasterArithmeticOperation.esriRasterPlus);
            IFunctionRasterDataset t1        = rsUtil.calcArithmaticFunction(t0, 2, esriRasterArithmeticOperation.esriRasterMultiply);
            IFunctionRasterDataset t2        = null;
            IFunctionRasterDataset transCost = null;

            if (OperationsCostRaster == null)
            {
                t2 = rsUtil.calcArithmaticFunction(t1, OperationsCost, esriRasterArithmeticOperation.esriRasterPlus);
            }
            else
            {
                t2 = rsUtil.calcArithmaticFunction(t1, OperationsCostRaster, esriRasterArithmeticOperation.esriRasterPlus);
            }
            if (OtherCostRaster == null)
            {
                transCost = rsUtil.calcArithmaticFunction(t2, OtherCost, esriRasterArithmeticOperation.esriRasterPlus);
            }
            else
            {
                transCost = rsUtil.calcArithmaticFunction(t2, OtherCostRaster, esriRasterArithmeticOperation.esriRasterPlus);
            }
            outDTR = transCost;
        }
Ejemplo n.º 23
0
        public void btnExecute_Click(object sender, EventArgs e)
        {
            string tblNm = txtOutNm.Text;

            if (tblNm == null || tblNm == "")
            {
                MessageBox.Show("You must specify a output name", "No Output", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            if (lsbRaster.Items.Count < 1)
            {
                MessageBox.Show("You must select at least on Raster", "No Rasters", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            IRasterBandCollection rsBc = new RasterClass();

            for (int i = 0; i < lsbRaster.Items.Count; i++)
            {
                rsBc.AppendBands((IRasterBandCollection)rstDic[lsbRaster.Items[i].ToString()]);
            }
            this.Visible = false;
            esriUtil.Forms.RunningProcess.frmRunningProcessDialog rp = new RunningProcess.frmRunningProcessDialog(false);
            DateTime dt = DateTime.Now;

            rp.addMessage("Building Raster Attribute Table. This may take a while...");
            rp.stepPGBar(10);
            rp.TopMost = true;
            rp.Show();
            try
            {
                string                 outDbStr = geoUtil.getDatabasePath(tblNm);
                string                 outName  = System.IO.Path.GetFileNameWithoutExtension(tblNm);
                IWorkspace             wks      = geoUtil.OpenWorkSpace(outDbStr);
                IFunctionRasterDataset fDset    = rsUtil.compositeBandFunction(rsBc);
                outtbl            = rsUtil.calcCombinRasterFunctionTable(fDset, wks, outName);
                this.DialogResult = DialogResult.OK;
            }
            catch (Exception ex)
            {
                rp.addMessage(ex.ToString());
            }
            finally
            {
                DateTime dt2 = DateTime.Now;
                TimeSpan ts  = dt2.Subtract(dt);
                string   t   = " in " + ts.Days.ToString() + " days " + ts.Hours.ToString() + " hours " + ts.Minutes.ToString() + " minutes and " + ts.Seconds.ToString() + " seconds .";
                rp.stepPGBar(100);
                rp.addMessage("Finished creating attribute table");
                rp.enableClose();
                this.Close();
            }
        }
Ejemplo n.º 24
0
        private void createDictionaryArray()
        {
            IEnvelope env1 = referenceRaster.RasterInfo.Extent;
            IEnvelope env2 = transformRaster.RasterInfo.Extent;

            env1.Intersect(env2);
            clipGeo = (IGeometry)env1;
            IFunctionRasterDataset minRs = rsUtil.calcArithmaticFunction(referenceRaster, transformRaster, esriRasterArithmeticOperation.esriRasterMinus);

            clipRs = rsUtil.clipRasterFunction(minRs, clipGeo, esriRasterClippingType.esriRasterClippingOutside);
            IPnt pntSize = new PntClass();

            pntSize.SetCoords(512, 512);
            IRasterCursor rsCur = ((IRaster2)rsUtil.createRaster(clipRs)).CreateCursorEx(pntSize);
            int           pCnt  = rsCur.PixelBlock.Planes;

            do
            {
                IPixelBlock pbMinBlock = rsCur.PixelBlock;
                for (int r = 0; r < pbMinBlock.Height; r++)
                {
                    for (int c = 0; c < pbMinBlock.Width; c++)
                    {
                        for (int p = 0; p < pCnt; p++)
                        {
                            object vlObj = pbMinBlock.GetVal(p, c, r);
                            if (vlObj == null)
                            {
                                continue;
                            }
                            else
                            {
                                int vl = System.Convert.ToInt32(vlObj);
                                Dictionary <int, int> cDic = difDic[p];
                                int cnt = 0;
                                if (!cDic.TryGetValue(vl, out cnt))
                                {
                                    cDic.Add(vl, 1);
                                }
                                else
                                {
                                    cDic[vl] = cnt + 1;
                                }
                                cellCount[p] += 1;
                            }
                        }
                    }
                }
            } while (rsCur.Next() == true);
        }
Ejemplo n.º 25
0
        private IFunctionRasterDataset calCov()
        {
            double N = (SumRws * SumClms * 2);
            IFunctionRasterDataset mvRst = getShiftedRaster(InRaster);
            IFunctionRasterDataset pRs   = rsUtil.calcArithmaticFunction(InRaster, mvRst, esriRasterArithmeticOperation.esriRasterPlus);
            IFunctionRasterDataset pRs2T = rsUtil.calcArithmaticFunction(InRaster, mvRst, esriRasterArithmeticOperation.esriRasterMultiply);
            IFunctionRasterDataset pRs2  = rsUtil.calcArithmaticFunction(pRs2T, 2, esriRasterArithmeticOperation.esriRasterMultiply);
            IFunctionRasterDataset mRsT  = rsUtil.calcFocalStatisticsFunction(pRs, SumClms, SumRws, rasterUtil.focalType.SUM);
            IFunctionRasterDataset mRsT2 = rsUtil.calcArithmaticFunction(mRsT, 2, esriRasterArithmeticOperation.esriRasterPower);
            IFunctionRasterDataset mRs   = rsUtil.calcArithmaticFunction(mRsT2, N, esriRasterArithmeticOperation.esriRasterDivide);
            IFunctionRasterDataset mRs2  = rsUtil.calcFocalStatisticsFunction(pRs2, SumClms, SumRws, rasterUtil.focalType.SUM);
            IFunctionRasterDataset dif   = rsUtil.calcArithmaticFunction(mRs2, mRs, esriRasterArithmeticOperation.esriRasterMinus);

            return(rsUtil.calcArithmaticFunction(dif, N, esriRasterArithmeticOperation.esriRasterDivide));
        }
 public void Bind(object pArgument)
 {
     if (pArgument is MathFunctionArguments)
     {
         MathFunctionArguments args = (MathFunctionArguments)pArgument;
         inrs = args.InRaster;
         myFunctionHelper.Bind(inrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: MathFunctionArguments");
     }
 }
Ejemplo n.º 27
0
 public void Bind(object pArgument)
 {
     if (pArgument is MathFunctionArguments)
     {
         MathFunctionArguments args = (MathFunctionArguments)pArgument;
         inrs = args.InRaster;
         myFunctionHelper.Bind(inrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype  = myRasterInfo.PixelType;
         myValidFlag  = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: MathFunctionArguments");
     }
 }
Ejemplo n.º 28
0
        private void setRasterType()
        {
            string wksPath = wks.PathName;

            if (wksPath.EndsWith(".accdb") || wksPath.EndsWith(".mdb") || wksPath.EndsWith(".sde"))
            {
                rsType = rasterUtil.rasterType.GDB;
            }
            else
            {
                rsType = rasterUtil.rasterType.IMAGINE;
            }
            string lastRS  = "";
            bool   checkNA = false;

            foreach (string s in System.IO.Directory.GetFiles(resultsDir, "arrivaltime*.txt"))
            {
                lastRS = System.IO.Path.GetFileNameWithoutExtension(s);
                string[] sArr   = lastRS.Split(new char[] { '_' });
                int      perNum = System.Convert.ToInt32(sArr[2]);
                if (perNum > numPer)
                {
                    numPer = perNum;
                }
                int firNum = System.Convert.ToInt32(sArr[1]);
                if (firNum > numFir)
                {
                    numFir = firNum;
                }
                int iterNum = System.Convert.ToInt32(sArr[0].Replace("arrivaltime", ""));
                if (iterNum == 0)
                {
                    checkNA = true;
                }
                if (iterNum > numIter)
                {
                    numIter = iterNum;
                }
                lastRS = s;
            }
            if (checkNA && numIter > 0)
            {
                iterLst.Add(0);
            }
            iterLst.Add(numIter);
            snapRaster = rsUtil.createIdentityRaster(lastRS);
        }
Ejemplo n.º 29
0
        private static Dictionary <string, double> getStrataProportion(IFunctionRasterDataset strataRaster, rasterUtil rsUtil)
        {
            IRaster2 rs2 = (IRaster2)rsUtil.createRaster(strataRaster);
            Dictionary <string, double> outDic = new Dictionary <string, double>();
            IRasterCursor rsCur = rs2.CreateCursorEx(null);
            //Console.WriteLine(((IRasterProps)rs2).Height.ToString() + ((IRasterProps)rs2).Height.ToString());
            int n = 0;

            do
            {
                IPixelBlock pb = rsCur.PixelBlock;
                //Console.WriteLine("PixelBLock w_h = " + pb.Width.ToString() + "_" + pb.Height.ToString());
                for (int r = 0; r < pb.Height; r++)
                {
                    for (int c = 0; c < pb.Width; c++)
                    {
                        object vlObj = pb.GetVal(0, c, r);
                        if (vlObj != null)
                        {
                            string vl = vlObj.ToString();
                            double vlCnt;
                            if (outDic.TryGetValue(vl, out vlCnt))
                            {
                                outDic[vl] = vlCnt + 1;
                            }
                            else
                            {
                                outDic.Add(vl, 1);
                            }
                            n += 1;
                        }
                        else
                        {
                            //Console.WriteLine("VL Null");
                        }
                    }
                }
            } while (rsCur.Next() == true);
            //Console.WriteLine("OutDic Count = " + outDic.Count.ToString());
            System.Runtime.InteropServices.Marshal.ReleaseComObject(rsCur);
            foreach (string s in outDic.Keys.ToArray())
            {
                double vl = outDic[s];
                outDic[s] = vl / n;
            }
            return(outDic);
        }
Ejemplo n.º 30
0
 public void Bind(object pArgument)
 {
     if (pArgument is convertPixelTypeFunctionArguments)
     {
         convertPixelTypeFunctionArguments arg = (convertPixelTypeFunctionArguments)pArgument;
         inrs      = arg.InRaster;
         convPType = arg.RasterPixelType;
         myFunctionHelper.Bind(inrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype  = myRasterInfo.PixelType;
         myValidFlag  = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: LocalFunctionArguments");
     }
 }
Ejemplo n.º 31
0
        public IFunctionRasterDataset getShiftedRaster(IFunctionRasterDataset rasterToShift)
        {
            IFunctionRasterDataset mvRst = null;
            double x = 0;
            double y = 0;

            if (Horizontal)
            {
                x = -1 * rasterToShift.RasterInfo.CellSize.X;
            }
            else
            {
                y = rasterToShift.RasterInfo.CellSize.Y;
            }
            mvRst = rsUtil.shiftRasterFunction(rasterToShift, x, y);
            return(mvRst);
        }
Ejemplo n.º 32
0
        private IFunctionRasterDataset createArivaltimeZones(IFunctionRasterDataset arrivalTime)
        {
            IRemapFilter      arrivalRemap = new RemapFilterClass();
            IRasterStatistics rsStats      = ((IRasterBandCollection)arrivalTime).Item(0).Statistics;

            if (rsStats == null)
            {
                rsUtil.calcStatsAndHist(arrivalTime);
                rsStats = ((IRasterBandCollection)arrivalTime).Item(0).Statistics;
            }
            else if (!rsStats.IsValid)
            {
                rsStats.SkipFactorX = 1;
                rsStats.SkipFactorY = 1;
                rsStats.Recalculate();
            }
            else
            {
            }
            double max  = rsStats.Maximum;
            double min  = rsStats.Minimum;
            double skip = 1;

            switch (arrCls)
            {
            case ArrivalClasses.Hours:
                skip = 60;
                break;

            case ArrivalClasses.Days:
                skip = 1440;
                break;

            default:
                break;
            }
            for (double i = 0; i <= max; i += skip)
            {
                double nVl = (i + skip) / skip;
                arrivalRemap.AddClass(min, i + skip, nVl);
            }
            IFunctionRasterDataset reRs = rsUtil.calcRemapFunction(arrivalTime, arrivalRemap);

            return(reRs);// reSampleRasterGrid(reRs);
        }
 public void Bind(object pArgument)
 {
     if (pArgument is LocalRescaleFunctionArguments)
     {
         LocalRescaleFunctionArguments arg = (LocalRescaleFunctionArguments)pArgument;
         inrsBands = arg.InRaster;
         bndCnt = inrsBands.RasterInfo.BandCount;
         bndCntf = System.Convert.ToSingle(bndCnt-1);
         myFunctionHelper.Bind(inrsBands);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: LocalFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is LocalFunctionArguments)
     {
         LocalFunctionArguments arg = (LocalFunctionArguments)pArgument;
         inrsBands = arg.InRaster;
         inrs = arg.outRaster;
         myFunctionHelper.Bind(inrs);
         //myFunctionHelperCoef.Bind(inrsBands);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: LocalFunctionArguments");
     }
 }
Ejemplo n.º 35
0
        private IFunctionRasterDataset transform()
        {
            IRasterBandCollection rsBc = new RasterClass();

            for (int i = 0; i < coef.Length; i++)
            {
                double[] c                 = coef[i];
                double   intercept         = c[0];
                double   slope             = c[1];
                IFunctionRasterDataset tRs = rsUtil.getBand(transformRaster, i);
                IFunctionRasterDataset pRs = rsUtil.calcArithmaticFunction(tRs, slope, esriRasterArithmeticOperation.esriRasterMultiply);
                IFunctionRasterDataset fRs = rsUtil.calcArithmaticFunction(pRs, intercept, esriRasterArithmeticOperation.esriRasterPlus);
                IFunctionRasterDataset bRs = rsUtil.convertToDifFormatFunction(fRs, rsType);
                rsBc.AppendBand(((IRasterBandCollection)bRs).Item(0));
            }
            OutRaster = rsUtil.compositeBandFunction(rsBc);
            return(OutRaster);
        }
 public void Bind(object pArgument)
 {
     if (pArgument is conditionalFunctionArguments)
     {
         conditionalFunctionArguments args = (conditionalFunctionArguments)pArgument;
         coefRs = args.CoefRaster;
         outRs = args.OutRaster;
         myFunctionHelper.Bind(outRs);
         myFunctionHelperCoef.Bind(coefRs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: Conditional arguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is PixelBlockToRasterFunctionArguments)
     {
         PixelBlockToRasterFunctionArguments args = (PixelBlockToRasterFunctionArguments)pArgument;
         inrs = args.InRaster;
         vPb = (IPixelBlock3)args.ValuePixelBlock;
         tlLoc = args.TopLeft;
         myFunctionHelper.Bind(inrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: PixelBlockToRasterArguments");
     }
 }
Ejemplo n.º 38
0
 public void Bind(object pArgument)
 {
     if (pArgument is conditionalFunctionArguments)
     {
         conditionalFunctionArguments args = (conditionalFunctionArguments)pArgument;
         coefRs = args.CoefRaster;
         outRs  = args.OutRaster;
         myFunctionHelper.Bind(outRs);
         myFunctionHelperCoef.Bind(coefRs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype  = myRasterInfo.PixelType;
         myValidFlag  = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: Conditional arguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is pcaArguments)
     {
         pcaArguments arg = (pcaArguments)pArgument;
         inrsBandsCoef = arg.InRasterCoefficients;
         outrs = arg.OutRaster;
         pca = arg.PCA;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperCoef.Bind(inrsBandsCoef);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: pcaFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is focalBandFunctionArguments)
     {
         focalBandFunctionArguments arg = (focalBandFunctionArguments)pArgument;
         inrsBands = arg.InRaster;
         myFunctionHelper.Bind(inrsBands);
         bandsBefore = arg.BandsBefore;
         bandsAfter = arg.BandsAfter;
         tBands = 1 + bandsBefore + bandsAfter;
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: focalBandArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is polytomousLogisticFunctionArguments)
     {
         polytomousLogisticFunctionArguments arg = (polytomousLogisticFunctionArguments)pArgument;
         inrsBandsCoef = arg.InRasterCoefficients;
         slopes = arg.Slopes;
         outrs = arg.OutRaster;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperCoef.Bind(inrsBandsCoef);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: regressionFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is meanShiftFunctionArguments)
     {
         meanShiftFunctionArguments args = (meanShiftFunctionArguments)pArgument;
         inrs = args.InRaster;
         radius = args.Radius;
         valrs = args.ValueRaster;
         myFunctionHelper.Bind(inrs);
         myFunctionHelper2.Bind(valrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: meanShiftArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is tobitFunctionArguments)
     {
         tobitFunctionArguments arg = (tobitFunctionArguments)pArgument;
         inrsBandsCoef = arg.InRasterCoefficients;
         slopes = arg.Slopes;
         outrs = arg.OutRaster;
         censored = arg.CensoredValue;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperCoef.Bind(inrsBandsCoef);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: tobitnFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is aggregationFunctionArguments)
     {
         aggregationFunctionArguments args = (aggregationFunctionArguments)pArgument;
         inrs = args.InRaster;
         orig = args.OriginalRaster;
         cells = args.Cells;
         myFunctionHelper.Bind(inrs);
         myFunctionHelperOrig.Bind(orig);
         //System.Windows.Forms.MessageBox.Show(orig.RasterInfo.CellSize.X.ToString()+"\n" + inrs.RasterInfo.CellSize.X.ToString());
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: aggregationFunctonArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is clusterFunctionArguments)
     {
         clusterFunctionArguments arg = (clusterFunctionArguments)pArgument;
         inrsBandsCoef = arg.InRasterCoefficients;
         outrs = arg.OutRaster;
         //Console.WriteLine("Number of Bands in outrs = " + ((IRasterBandCollection)outrs).Count.ToString());
         cluster = (Statistics.dataPrepClusterBinary)arg.ClusterModel;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperCoef.Bind(inrsBandsCoef);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: plrFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is softMaxFunctionArguments)
     {
         softMaxFunctionArguments arg = (softMaxFunctionArguments)pArgument;
         inrsBandsCoef = arg.InRasterCoefficients;
         outrs = arg.OutRaster;
         xVls = new double[((IRasterBandCollection)inrsBandsCoef).Count];
         //Console.WriteLine("Number of Bands in outrs = " + ((IRasterBandCollection)outrs).Count.ToString());
         lm = arg.LogitModel;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperCoef.Bind(inrsBandsCoef);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: plrFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is focalSampleArguments)
     {
         focalSampleArguments args = (focalSampleArguments)pArgument;
         inrs = args.InRaster;
         orig = args.OriginalRaster;
         inop = args.Operation;
         offset = args.OffSets;
         getPlusWidthHeight();
         myFunctionHelper.Bind(inrs);
         myFunctionHelperOrig.Bind(orig);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: focalSampleFunctonArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is pairedttestFunctionArguments)
     {
         pairedttestFunctionArguments arg = (pairedttestFunctionArguments)pArgument;
         inrsBandsCoef = arg.InRasterCoefficients;
         outrs = arg.OutRaster;
         //Console.WriteLine("Number of Bands in outrs = " + ((IRasterBandCollection)outrs).Count.ToString());
         tDic = arg.TTestDictionary;
         IRasterProps rsProp = (IRasterProps)outrs;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperCoef.Bind(inrsBandsCoef);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: plrFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is mergeFunctionArguments)
     {
         mergeFunctionArguments arg = (mergeFunctionArguments)pArgument;
         inrs = arg.InRaster;
         outrs = arg.OutRaster;
         //Console.WriteLine("Number of Bands in outrs = " + ((IRasterBandCollection)outrs).Count.ToString());
         ftrCls = arg.Boundary;
         //ftrCls = arg.Boundary.Catalog;
         catIndex = ftrCls.FindField("catIndex");
         IRasterProps rsProp = (IRasterProps)outrs;
         myFunctionHelper.Bind(outrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: mergeFunctionArguments");
     }
 }
 public void Bind(object pArgument)
 {
     if (pArgument is regionGroupFunctionArguments)
     {
         regionGroupFunctionArguments arg = (regionGroupFunctionArguments)pArgument;
         inrs = arg.InRaster;
         outrs = arg.OutRaster;
         //Console.WriteLine("Number of Bands in outrs = " + ((IRasterBandCollection)outrs).Count.ToString());
         rsProp = (IRasterProps)outrs;
         width = rsProp.Width;
         height = rsProp.Height;
         myFunctionHelper.Bind(outrs);
         myFunctionHelperInput.Bind(inrs);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: randomForestArguments");
     }
 }
 public normalization(IFunctionRasterDataset ReferenceRaster, IFunctionRasterDataset TransformRaster, int PercentChange = 20, rasterUtil rasterUtility = null)
 {
     referenceRaster = ReferenceRaster;
     IRasterBandCollection rsBc = (IRasterBandCollection)referenceRaster;
     rsType = referenceRaster.RasterInfo.PixelType;
     cellCount = new int[rsBc.Count];
     minArray = new double[rsBc.Count];
     maxArray = new double[rsBc.Count];
     sumX2Array = new double[rsBc.Count];
     sumXArray = new double[rsBc.Count];
     sumXYArray = new double[rsBc.Count];
     sumYArray = new double[rsBc.Count];
     sumY2Array = new double[rsBc.Count];
     coef = new double[rsBc.Count][];
     blockCellCount = new int[rsBc.Count];
     difDic = new Dictionary<double, int>[rsBc.Count];
     for (int i = 0; i < rsBc.Count; i++)
     {
         difDic[i] = new Dictionary<double, int>();
     }
     transformRaster = TransformRaster;
     pChange = System.Convert.ToDouble(PercentChange) / 200d;
     rsUtil = rasterUtility;
 }
 public void Bind(object pArgument)
 {
     if (pArgument is LandscapeFunctionArguments)
     {
         LandscapeFunctionArguments args = (LandscapeFunctionArguments)pArgument;
         inrs = args.InRaster;
         orig = args.OriginalRaster;
         inop = args.Operation;
         landType = args.LandscapeType;
         inWindow = args.WindowType;
         clms = args.Columns;
         rws = args.Rows;
         radius = args.Radius;
         myFunctionHelper.Bind(inrs);
         myFunctionHelperCoef.Bind(orig);
         myRasterInfo = myFunctionHelper.RasterInfo;
         myPixeltype = myRasterInfo.PixelType;
         myValidFlag = true;
     }
     else
     {
         throw new System.Exception("Incorrect arguments object. Expected: FocalFunctonArguments");
     }
 }
        private static Dictionary<string, double> getStrataProportion(IFunctionRasterDataset strataRaster,rasterUtil rsUtil)
        {
            IRaster2 rs2 = (IRaster2)rsUtil.createRaster(strataRaster);
            Dictionary<string, double> outDic = new Dictionary<string, double>();
            IRasterCursor rsCur = rs2.CreateCursorEx(null);
            //Console.WriteLine(((IRasterProps)rs2).Height.ToString() + ((IRasterProps)rs2).Height.ToString());
            int n = 0;
            do
            {
                IPixelBlock pb = rsCur.PixelBlock;
                //Console.WriteLine("PixelBLock w_h = " + pb.Width.ToString() + "_" + pb.Height.ToString());
                for (int r = 0; r < pb.Height; r++)
                {
                    for (int c = 0; c < pb.Width; c++)
                    {
                        object vlObj = pb.GetVal(0, c, r);
                        if (vlObj != null)
                        {
                            string vl = vlObj.ToString();
                            double vlCnt;
                            if (outDic.TryGetValue(vl, out vlCnt))
                            {
                                outDic[vl] = vlCnt + 1;
                            }
                            else
                            {
                                outDic.Add(vl, 1);
                            }
                            n += 1;
                        }
                        else
                        {
                            //Console.WriteLine("VL Null");
                        }

                    }
                }
            } while (rsCur.Next() == true);
            //Console.WriteLine("OutDic Count = " + outDic.Count.ToString());
            System.Runtime.InteropServices.Marshal.ReleaseComObject(rsCur);
            foreach (string s in outDic.Keys.ToArray())
            {
                double vl = outDic[s];
                outDic[s] = vl / n;
            }
            return outDic;
        }
 private static Dictionary<string, double[][]> getDictionaryValues(ESRI.ArcGIS.Geodatabase.IFeatureClass pointFtr, ESRI.ArcGIS.Geodatabase.IField[] fldsToSummarize, IFunctionRasterDataset strataRaster, geoDatabaseUtility geoUtil, rasterUtil rsUtil)
 {
     IRaster2 rs2 = (IRaster2)rsUtil.createRaster(strataRaster);
     int[] ptfldIndex = new int[fldsToSummarize.Length];
     for (int i = 0; i < ptfldIndex.Length; i++)
     {
         ptfldIndex[i] = pointFtr.FindField(fldsToSummarize[i].Name);
     }
     Dictionary<string, double[][]> outDic = new Dictionary<string, double[][]>();
     IFeatureCursor sCur = pointFtr.Search(null, true);
     IFeature sFtr = sCur.NextFeature();
     while (sFtr != null)
     {
         IGeometry geo = sFtr.Shape;
         IPoint pnt = (IPoint)geo;
         int clm, rw;
         rs2.MapToPixel(pnt.X, pnt.Y,out clm, out rw);
         object strataVlObj = rs2.GetPixelValue(0, clm, rw);
         if(strataVlObj!=null)
         {
             string strataVl = strataVlObj.ToString();
             double[][] vlArr;
             if (outDic.TryGetValue(strataVl, out vlArr))
             {
                 for (int i = 0; i < ptfldIndex.Length; i++)
                 {
                     object vlObj = sFtr.get_Value(ptfldIndex[i]);
                     if (vlObj != null)
                     {
                         double vl = System.Convert.ToDouble(vlObj);
                         vlArr[i][0] += vl;
                         vlArr[i][1] += (vl * vl);
                         vlArr[i][2] += 1;
                     }
                 }
             }
             else
             {
                 vlArr = new double[fldsToSummarize.Length][];
                 for (int i = 0; i < ptfldIndex.Length; i++)
                 {
                     double[] vlSumArr = new double[3];
                     object vlObj =sFtr.get_Value(ptfldIndex[i]);
                     if (vlObj != null)
                     {
                         double vl =  System.Convert.ToDouble(vlObj);
                         vlSumArr[0] = vl;
                         vlSumArr[1] = (vl * vl);
                         vlSumArr[2] = 1;
                     }
                     vlArr[i] = vlSumArr;
                 }
                 outDic[strataVl] = vlArr;
             }
         }
         sFtr = sCur.NextFeature();
     }
     System.Runtime.InteropServices.Marshal.ReleaseComObject(sCur);
     return outDic;
 }
        public static void summarizeBiomassPolygon(IFeatureClass pointFtr, IField[] fldsToSummarize, IFunctionRasterDataset strataRaster, IFeatureClass standsFtr, geoDatabaseUtility geoUtil = null, rasterUtil rsUtil = null)
        {
            if (geoUtil == null) geoUtil = new geoDatabaseUtility();
            if(rsUtil == null) rsUtil = new rasterUtil();
            int cnt = 0;
            //need to work on calculating N
            Dictionary<string,double[][]> vlDic = getDictionaryValues(pointFtr, fldsToSummarize, strataRaster, geoUtil, rsUtil); //Strata: SummaryFields [{sum,sum2,cnt},...]
            int[] meanFldIndex = new int[fldsToSummarize.Length];
            int[] varFldIndex = new int[fldsToSummarize.Length];
            int[] cntFldIndex = new int[fldsToSummarize.Length];
            //string cntName = geoUtil.createField(standsFtr, "n", esriFieldType.esriFieldTypeInteger, false);
            //int cntIndex = standsFtr.FindField(cntName);
            foreach (IField fld in fldsToSummarize)
            {
                string sName = geoUtil.createField(standsFtr, "v_" + fld.Name, esriFieldType.esriFieldTypeDouble, false);
                varFldIndex[cnt] = standsFtr.FindField(sName);
                string mName = geoUtil.createField(standsFtr, "m_" + fld.Name, esriFieldType.esriFieldTypeDouble, false);
                meanFldIndex[cnt] = standsFtr.FindField(mName);
                string cntName = geoUtil.createField(standsFtr, "n_" + fld.Name, esriFieldType.esriFieldTypeDouble, false);
                cntFldIndex[cnt] = standsFtr.FindField(cntName);
                cnt++;
            }
            IFeatureCursor uCur = standsFtr.Update(null, true);
            IFeature uFtr = uCur.NextFeature();
            while (uFtr != null)
            {
                ESRI.ArcGIS.Geometry.IGeometry geo = uFtr.Shape;
                IFunctionRasterDataset cRs = rsUtil.clipRasterFunction(strataRaster, geo, esriRasterClippingType.esriRasterClippingOutside);
                //Console.WriteLine("Clipping raster");
                Dictionary<string, double> rsStrataPropDic = getStrataProportion(cRs,rsUtil); //Strata: proportion of area
                //int tn = 0;
                //double[] tn = new double[meanFldIndex.Length];
                double[][] updateValuesArr = new double[meanFldIndex.Length][];
                for (int i = 0; i < meanFldIndex.Length; i++)
                {
                    updateValuesArr[i] = new double[3];
                }
                foreach (KeyValuePair<string, double> kvp in rsStrataPropDic)
                {
                    string stratum = kvp.Key;
                    double proportion = kvp.Value;
                    //Console.WriteLine(stratum + " = " + proportion.ToString());
                    double[][] vlDicArr;
                    if (vlDic.TryGetValue(stratum, out vlDicArr))
                    {
                        //double n = vlDicArr[0][2];
                        //tn += System.Convert.ToInt32(n);
                        for (int i = 0; i < meanFldIndex.Length; i++)
                        {
                            double[] dArr = vlDicArr[i];
                            double n = dArr[2];
                            //tn[i] += n;
                            double s=dArr[0];
                            double s2=dArr[1];
                            updateValuesArr[i][0] += (s/n) * proportion;//mean
                            updateValuesArr[i][1] += (s2-Math.Pow(s,2)/n)/(n-1) * proportion;//variance
                            updateValuesArr[i][2] += n;
                        }

                    }
                }
                //uFtr.set_Value(cntIndex, tn);
                for (int i = 0; i < meanFldIndex.Length; i++)
                {
                    uFtr.set_Value(meanFldIndex[i], updateValuesArr[i][0]);
                    uFtr.set_Value(varFldIndex[i], updateValuesArr[i][1]);
                    uFtr.set_Value(cntFldIndex[i], updateValuesArr[i][2]);
                }
                uCur.UpdateFeature(uFtr);
                uFtr = uCur.NextFeature();
            }
            System.Runtime.InteropServices.Marshal.ReleaseComObject(uCur);
        }
 public void GetFinalRaster(out string nm, out IFunctionRasterDataset rs, out string desc)
 {
     nm = "";
     rs = null;
     desc = "";
     //System.Windows.Forms.MessageBox.Show("LstName = " + lstName+ " and has dictionary value = " + rstDic.ContainsKey(lstName).ToString());
     if (rstDic.ContainsKey(lstName))
     {
         nm = lstName;
         rs = rstDic[lstName];
         desc = lnLst[lnLst.Count - 1];
     }
 }
 private void btnExecute_Click(object sender, EventArgs e)
 {
     string rstNm = txtOutNm.Text;
     string funNm = cmbFunction.Text;
     int before = System.Convert.ToInt32(nudBefore.Value);
     int after = System.Convert.ToInt32(nudAfter.Value);
     if (rstNm == null || rstNm == "")
     {
         MessageBox.Show("You must specify a output name","No Output",MessageBoxButtons.OK,MessageBoxIcon.Error);
         return;
     }
     if (lsbRaster.Items.Count < 1)
     {
         MessageBox.Show("You must select at least on Raster", "No Rasters", MessageBoxButtons.OK, MessageBoxIcon.Error);
         return;
     }
     if ( funNm==null||funNm=="")
     {
         MessageBox.Show("You must select at least on function", "No Function Selected", MessageBoxButtons.OK, MessageBoxIcon.Error);
         return;
     }
     IRasterBandCollection rsBc = new RasterClass();
     for (int i = 0; i < lsbRaster.Items.Count; i++)
     {
         rsBc.AppendBands((IRasterBandCollection)rstDic[lsbRaster.Items[i].ToString()]);
     }
     IFunctionRasterDataset fdset = rsUtil.compositeBandFunction(rsBc);
     rasterUtil.localType op = (rasterUtil.localType)Enum.Parse(typeof(rasterUtil.localType),funNm);
     this.Visible = false;
     esriUtil.Forms.RunningProcess.frmRunningProcessDialog rp = new RunningProcess.frmRunningProcessDialog(false);
     DateTime dt = DateTime.Now;
     rp.addMessage("Calculating raster values. This may take a while...");
     rp.stepPGBar(10);
     rp.TopMost = true;
     rp.Show();
     try
     {
         outraster = rsUtil.focalBandfunction(fdset,op,before,after);
         //rp.addMessage("Number of bands = " + ((IRasterBandCollection)outraster).Count);
         if (mp != null&&addToMap)
         {
             rp.addMessage("Calculating Statistics...");
             rp.Refresh();
             IRasterLayer rstLyr = new RasterLayerClass();
             //rsUtil.calcStatsAndHist(((IRaster2)outraster).RasterDataset);
             rstLyr.CreateFromDataset((IRasterDataset)outraster);
             rstLyr.Name = rstNm;
             rstLyr.Visible = false;
             mp.AddLayer(rstLyr);
         }
         outrastername = rstNm;
         this.DialogResult = DialogResult.OK;
     }
     catch (Exception ex)
     {
         rp.addMessage(ex.ToString());
     }
     finally
     {
         DateTime dt2 = DateTime.Now;
         TimeSpan ts = dt2.Subtract(dt);
         string t = " in " + ts.Days.ToString() + " days " + ts.Hours.ToString() + " hours " + ts.Minutes.ToString() + " minutes and " + ts.Seconds.ToString() + " seconds .";
         rp.stepPGBar(100);
         rp.addMessage("Finished Creating Rasters" + t);
         rp.enableClose();
         this.Close();
     }
 }
 public void addRasterToComboBox(string rstName, IFunctionRasterDataset rst)
 {
     if (!cmbInRaster1.Items.Contains(rstName))
     {
         cmbInRaster1.Items.Add(rstName);
         rstDic[rstName]= rst;
     }
 }
        public void convertFeatureToRaster(IFeatureClass InFeatureClass, string fldName)
        {
            ftrCls = InFeatureClass;
            ftrField = fldName;
            IDataset dSet = (IDataset)InFeatureClass;
            string outRsNm = dSet.BrowseName;
            wks = dSet.Workspace;
            if (vRs != null)
            {
                if (!checkProjectionsFtr())
                {
                    if (rd != null) rd.addMessage("Re-projecting feature class to match value raster's projection");
                    InFeatureClass = reprojectInFeatureClass(InFeatureClass, vRs.RasterInfo.SpatialReference);

                }
            }
            IWorkspace wksTemp = geoUtil.OpenRasterWorkspace(tempWksStr);
            IFunctionRasterDataset rs = rsUtil.createIdentityRaster(rsUtil.convertFeatureClassToRaster(InFeatureClass, rasterUtil.rasterType.IMAGINE, wksTemp, outRsNm, vRs.RasterInfo.CellSize.X, (IRasterDataset)vRs));
            rs = rsUtil.createIdentityRaster(rs, rstPixelType.PT_FLOAT);
            int fieldIndex = InFeatureClass.FindField(fldName);
            if(fieldIndex == -1)
            {
                fieldIndex = InFeatureClass.FindField(fldName + "_1");
            }
            if (fldName.ToLower() == InFeatureClass.OIDFieldName.ToLower()||fieldIndex == -1)
            {
                zRs = rs;
            }
            else
            {
                IRemapFilter rFilt = new RemapFilterClass();
                IFeatureCursor ftrCur = InFeatureClass.Search(null, false);
                IFeature ftr = ftrCur.NextFeature();

                while (ftr != null)
                {
                    double id = ftr.OID;
                    double nVl = System.Convert.ToDouble(ftr.get_Value(fieldIndex));
                    if (Double.IsNaN(nVl) || Double.IsInfinity(nVl))
                    {
                        ftr = ftrCur.NextFeature();
                    }
                    else
                    {
                        //Console.WriteLine("adding oid = " + id.ToString() + " and value = " + nVl.ToString());
                        rFilt.AddClass(id, id + 1, nVl);
                        ftr = ftrCur.NextFeature();
                    }
                }
                zRs = rsUtil.calcRemapFunction(rs, rFilt);
            }
        }
 public IFunctionRasterDataset getShiftedRaster(IFunctionRasterDataset rasterToShift)
 {
     IFunctionRasterDataset mvRst = null;
     double x = 0;
     double y = 0;
     if (Horizontal)
     {
         x = -1 * rasterToShift.RasterInfo.CellSize.X;
     }
     else
     {
         y = rasterToShift.RasterInfo.CellSize.Y;
     }
     mvRst = rsUtil.shiftRasterFunction(rasterToShift, x, y);
     return mvRst;
 }