Esempio n. 1
0
        /// <summary>
        /// Chunk op implementation
        /// </summary>
        /// <param name="data"></param>
        /// <param name="outChunk"></param>
        protected override void ChunkOp(List <double[]> data, List <double[]> outBuffers)
        {
            // Get all the points in this chunk
            VectorChunkExtent       = ChunkExtent.Buffer(_fsizedec);
            List <Geometry>[,] bins = BinPoints(_vinput.GeometriesIntersectExtent(VectorChunkExtent));

            for (int cid = 0; cid < outBuffers[0].Length; cid++)
            {
                // Save us a metric Tonne of effort by giving up on nodatavals in the DEM
                if (data[0][cid] == inNodataVals[0])
                {
                    outBuffers[0][cid] = outNodataVals[0];
                }
                else
                {
                    double outval = 0;

                    decimal[] cidxy = ChunkExtent.Id2XY(cid);
                    Geometry  pt2   = new Geometry(wkbGeometryType.wkbPoint);
                    pt2.AddPoint((double)cidxy[0], (double)cidxy[1], 0);

                    List <int[]> bins2test = GetRelevantBins(pt2);

                    // create a circle and then buffer it.
                    foreach (int[] binids in bins2test)
                    {
                        if (binids[0] < bins.GetLength(0) && binids[1] < bins.GetLength(1))
                        {
                            foreach (Geometry pt in bins[binids[0], binids[1]])
                            {
                                // If we're a circle we have to do a more expensive operation now
                                if (_kshape == RasterOperators.KernelShapes.Circle)
                                {
                                    if (InsideRadius(pt, pt2))
                                    {
                                        outval++;
                                    }
                                }
                                else if (InsideSquare(pt, pt2))
                                {
                                    outval++;
                                }
                            }
                        }
                    }
                    outBuffers[0][cid] = outval / area;
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="data"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        protected override void CellOp(List <double[]> data, List <double[]> outputs, int id)
        {
            outputs[0][id] = outNodataVals[0];

            // Speed things up by ignoring nodatas
            if (data[0][id] == inNodataVals[0])
            {
                return;
            }

            // With multimethod errors we need to do some fancy footwork
            if (_hasVectorPolymask)
            {
                if (_shapemask.Count > 0)
                {
                    decimal[] ptcoords = ChunkExtent.Id2XY(id);
                    // Is this point in one (or more) of the shapes?
                    List <string> shapes = _polymask.ShapesContainPoint((double)ptcoords[0], (double)ptcoords[1], _fieldname);

                    // Now we need to decide what to do based on how many intersections we found.
                    if (shapes.Count == 1)
                    {
                        outputs[0][id] = CellChangeCalc(shapes[0], data, id);
                    }
                    else if (shapes.Count > 1)
                    {
                        throw new NotImplementedException("Overlapping shapes is not yet supported");
                    }
                }
            }
            else if (_hasRasterizedPolymask)
            {
                // The rasterized polymask layer will always be Raster [1].
                double rPolymaskVal = data[1][id];
                if (rPolymaskVal != inNodataVals[1])
                {
                    string fldVal = _rasterVectorFieldVals[(int)rPolymaskVal];
                    outputs[0][id] = CellChangeCalc(fldVal, data, id);
                }
            }
            // Single method is easier
            else
            {
                outputs[0][id] = CellChangeCalc("", data, id);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// The budget seggregator looks to see if a cell is inside any of the features
        /// </summary>
        /// <param name="data"></param>
        /// <param name="id"></param>
        private void VectorBudgetSegCellOp(List <double[]> data, int id)
        {
            if (_shapemask.Count > 0)
            {
                decimal[]     ptcoords = ChunkExtent.Id2XY(id);
                List <string> shapes   = _polymask.ShapesContainPoint((double)ptcoords[0], (double)ptcoords[1], _fieldname, _shapemask);
                if (shapes.Count > 0)
                {
                    foreach (string fldVal in shapes)
                    {
                        if (!SegStats.ContainsKey(fldVal))
                        {
                            SegStats[fldVal] = new DoDStats(Stats);
                        }

                        CellChangeCalc(data, id, SegStats[fldVal]);
                    }
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// The budget seggregator looks to see if a cell is inside any of the features
        /// </summary>
        /// <param name="data"></param>
        /// <param name="id"></param>
        private void VectorBudgetSegCellOp(List <double[]> data, int id)
        {
            if (_shapemask.Count > 0)
            {
                decimal[]     ptcoords = ChunkExtent.Id2XY(id);
                List <string> shapes   = _polymask.ShapesContainPoint((double)ptcoords[0], (double)ptcoords[1], _fieldname, _shapemask);
                if (shapes.Count > 0)
                {
                    foreach (string fldVal in shapes)
                    {
                        if (!SegHistograms.ContainsKey(fldVal))
                        {
                            SegHistograms[fldVal] = new Histogram(_segNumBins, _inputRasters[0]);
                        }

                        SegHistograms[fldVal].AddBinVal(data[0][id]);
                    }
                }
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Find the intersection of each cell
        /// </summary>
        /// <param name="data"></param>
        /// <param name="outputs"></param>
        /// <param name="id"></param>
        protected override void CellOp(List <int[]> data, List <int[]> outputs, int id)
        {
            outputs[0][id] = outNodataVals[0];

            if (_shapemask.Count > 0 && data[0][id] != inNodataVals[0])
            {
                decimal[]     ptcoords = ChunkExtent.Id2XY(id);
                List <string> shapes   = _polymask.ShapesContainPoint((double)ptcoords[0], (double)ptcoords[1], _fieldname, _shapemask);

                if (shapes.Count > 0)
                {
                    // Add a dictionary entry if we need to
                    if (!_fieldvals.Contains(shapes[0]))
                    {
                        _fieldvals.Add(shapes[0]);
                    }

                    // 0 is our nodataval here so we pad the list by 1.
                    // Now we just need to remember that the raster is perpertually off by one
                    outputs[0][id] = _fieldvals.IndexOf(shapes[0]) + 1;
                }
            }
        }
Esempio n. 6
0
        /// <summary>
        /// The actual cell-by-cell operations
        /// </summary>
        /// <param name="data"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        protected override void CellOp(List <T[]> data, List <T[]> outputs, int id)
        {
            T val = outNodataVals[0];

            // This is the raster and scalar case
            if (_scalar)
            {
                if (!data[0][id].Equals(inNodataVals[0]))
                {
                    switch (_type)
                    {
                    // Choose your math operation
                    case RasterOperators.MathOpType.Addition:
                        val = DynamicMath.Add(data[0][id], _operand);
                        break;

                    case RasterOperators.MathOpType.Subtraction:
                        val = DynamicMath.Subtract(data[0][id], _operand);
                        break;

                    case RasterOperators.MathOpType.Multipication:
                        val = DynamicMath.Multiply(data[0][id], _operand);
                        break;

                    case RasterOperators.MathOpType.Division:
                        val = DynamicMath.Divide(data[0][id], _operand);
                        break;
                    }
                }
            }
            // This is the two raster case
            else
            {
                bool masked = false;

                // Pure vector method. (This is the slow way)
                if (_hasVectorPolymask)
                {
                    decimal[]   ptcoords = ChunkExtent.Id2XY(id);
                    List <long> shapes   = _polymask.ShapesContainPoint((double)ptcoords[0], (double)ptcoords[1], _shapemask);
                    if (shapes.Count == 0)
                    {
                        masked = true;
                    }
                }

                // Rasterized vector method
                else if (_hasRasterizedPolymask && data.Count == 3 && data[2][id].Equals(inNodataVals[2]))
                {
                    masked = true;
                }


                if (!data[0][id].Equals(inNodataVals[0]) && !data[1][id].Equals(inNodataVals[1]) && !masked)
                {
                    switch (_type)
                    {
                    // Choose your math operation
                    case RasterOperators.MathOpType.Addition:
                        val = DynamicMath.Add(data[0][id], data[1][id]);
                        break;

                    case RasterOperators.MathOpType.Subtraction:
                        val = DynamicMath.Subtract(data[0][id], data[1][id]);
                        break;

                    case RasterOperators.MathOpType.Multipication:
                        val = DynamicMath.Multiply(data[0][id], data[1][id]);
                        break;

                    case RasterOperators.MathOpType.Division:
                        val = DynamicMath.Divide(data[0][id], data[1][id]);
                        break;
                    }
                }
            }
            outputs[0][id] = val;
        }