/// <summary>
 /// Returns a CoordinateSequence based on the given coordinate sequence; whether or not the
 /// array is copied is implementation-dependent.
 /// </summary>
 /// <param name="coordSeq"></param>
 /// <returns></returns>
 public ICoordinateSequence Create(ICoordinateSequence coordSeq)
 {
     if (type == PackedType.Double)
     {
         return(new PackedDoubleCoordinateSequence(coordSeq.ToCoordinateArray(), dimension));
     }
     return(new PackedFloatCoordinateSequence(coordSeq.ToCoordinateArray(), dimension));
 }
Beispiel #2
0
        public static Point3d?GetCentroid(IList <Point3d> points)
        {
            Point3d?result      = null;
            var     coordinates = new List <Coordinate>();

            foreach (var point in points)
            {
                var coordinate = new Coordinate()
                {
                    X = point.X,
                    Y = point.Y,
                    Z = 0
                };
                coordinates.Add(coordinate);
            }
            ICoordinateSequence coordinateSequence = CoordinateArraySequenceFactory.Instance.Create(coordinates.ToArray());

            var geometryF = new DwgWriter();
            var polygon   = geometryF.GeometryFactory.CreatePolygon(coordinateSequence.ToCoordinateArray());
            var coords    = Centroid.GetCentroid(polygon);

            if (coords != null)
            {
                result = new Point3d(coords.X, coords.Y, coords.Z);
            }
            return(result);
        }
Beispiel #3
0
        ///** Convience method for STRUCT construction. */
        //private STRUCT toSTRUCT( Datum attributes[], String dataType )
        //        throws SQLException
        //{
        //    if( dataType.startsWith("*.")){
        //        dataType = "DRA."+dataType.substring(2);//TODO here
        //    }
        //    StructDescriptor descriptor =
        //        StructDescriptor.createDescriptor( dataType, connection );

        //     return new STRUCT( descriptor, connection, attributes );
        //}

        ///**
        // * Convience method for ARRAY construction.
        // * <p>
        // * Compare and contrast with toORDINATE - which treats <code>Double.NaN</code>
        // * as<code>NULL</code></p>
        // */
        //private ARRAY toARRAY( double doubles[], String dataType )
        //        throws SQLException
        //{
        //    ArrayDescriptor descriptor =
        //        ArrayDescriptor.createDescriptor( dataType, connection );

        //     return new ARRAY( descriptor, connection, doubles );
        //}

        ///**
        // * Convience method for ARRAY construction.
        // */
        //private ARRAY toARRAY( int ints[], String dataType )
        //    throws SQLException
        //{
        //    ArrayDescriptor descriptor =
        //        ArrayDescriptor.createDescriptor( dataType, connection );

        //     return new ARRAY( descriptor, connection, ints );
        //}

        ///**
        // * Convience method for NUMBER construction.
        // * <p>
        // * Double.NaN is represented as <code>NULL</code> to agree
        // * with JTS use.</p>
        // */
        //private NUMBER toNUMBER( double number ) throws SQLException{
        //    if( Double.isNaN( number )){
        //        return null;
        //    }
        //    return new NUMBER( number );
        //}

        /**
         * reverses the coordinate order
         *
         * @param factory
         * @param sequence
         *
         * @return CoordinateSequence reversed sequence
         */
        private ICoordinateSequence reverse(ICoordinateSequenceFactory factory, ICoordinateSequence sequence)
        {
            var list = new CoordinateList(sequence.ToCoordinateArray());

            list.Reverse();
            return(factory.Create(list.ToCoordinateArray()));
        }
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        protected override Envelope ComputeEnvelopeInternal()
        {
            if (IsEmpty)
            {
                return(new Envelope());
            }

            //Convert to array, then access array directly, to avoid the function-call overhead
            //of calling Getter millions of times. ToArray may be inefficient for
            //non-BasicCoordinateSequence CoordinateSequences. [Jon Aquino]
            Coordinate[] coordinates = _points.ToCoordinateArray();
            double       minx        = coordinates[0].X;
            double       miny        = coordinates[0].Y;
            double       maxx        = coordinates[0].X;
            double       maxy        = coordinates[0].Y;

            for (int i = 1; i < coordinates.Length; i++)
            {
                minx = minx < coordinates[i].X ? minx : coordinates[i].X;
                maxx = maxx > coordinates[i].X ? maxx : coordinates[i].X;
                miny = miny < coordinates[i].Y ? miny : coordinates[i].Y;
                maxy = maxy > coordinates[i].Y ? maxy : coordinates[i].Y;
            }
            return(new Envelope(minx, maxx, miny, maxy));
        }
Beispiel #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="coords"></param>
        /// <param name="parent"></param>
        /// <returns></returns>
        protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
        {
            var srcPts = coords.ToCoordinateArray();
            var newPts = SnapLine(srcPts, _snapPts);

            return(Factory.CoordinateSequenceFactory.Create(newPts));
        }
Beispiel #6
0
        /// <summary>
        /// Creates a <see cref="LineString" /> whose coordinates are in the reverse order of this objects.
        /// </summary>
        /// <returns>A <see cref="LineString" /> with coordinates in the reverse order.</returns>
        public ILineString Reverse()
        {
            ICoordinateSequence seq = (ICoordinateSequence)points.Clone();

            // Personalized implementation using Array.Reverse: maybe it's faster?
            ICoordinate[] array = seq.ToCoordinateArray();
            Array.Reverse(array);
            return(Factory.CreateLineString(array));
        }
            /// <inheritdoc cref="GeometryTransformer.TransformCoordinates(ICoordinateSequence, IGeometry)"/>
            protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
            {
                var inputPts = coords.ToCoordinateArray();
                var newPts   = inputPts.Length == 0
                    ? new Coordinate[0]
                    : DouglasPeuckerLineSimplifier.Simplify(inputPts, _container.DistanceTolerance);

                return(Factory.CoordinateSequenceFactory.Create(newPts));
            }
Beispiel #8
0
            protected override ICoordinateSequence TransformCoordinates(
                ICoordinateSequence coords, IGeometry parent)
            {
                var inputPts = coords.ToCoordinateArray();
                var newPts   = Densifier
                               .DensifyPoints(inputPts, _distanceTolerance, parent.PrecisionModel);

                // prevent creation of invalid LineStrings
                if (parent is ILineString && newPts.Length == 1)
                {
                    newPts = new Coordinate[0];
                }
                return(Factory.CoordinateSequenceFactory.Create(newPts));
            }
Beispiel #9
0
 protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
 {
     Coordinate[] inputPts = coords.ToCoordinateArray();
     Coordinate[] newPts;
     if (inputPts.Length == 0)
     {
         newPts = new Coordinate[0];
     }
     else
     {
         newPts = VWLineSimplifier.Simplify(inputPts, _distanceTolerance);
     }
     return(Factory.CoordinateSequenceFactory.Create(newPts));
 }
Beispiel #10
0
        /// <summary>
        /// Creates a <see cref="LineString" /> whose coordinates are in the reverse order of this objects.
        /// </summary>
        /// <returns>A <see cref="LineString" /> with coordinates in the reverse order.</returns>
        public virtual ILineString Reverse()
        {
            ICoordinateSequence seq = (ICoordinateSequence)points.Clone();

            // Personalized implementation using Array.Reverse: maybe it's faster?
            ICoordinate[] array = seq.ToCoordinateArray();
            Array.Reverse(array);
            return(Factory.CreateLineString(array));

            /*
             * // Standard implementation : direct port of JTS code
             * CoordinateSequences.Reverse(seq);
             * return Factory.CreateLineString(seq);
             */
        }
 private ICoordinateSequence Add(ICoordinateSequence seq1, ICoordinateSequence seq2)
 {
     if (seq1 == null)
     {
         return(seq2);
     }
     if (seq2 == null)
     {
         return(seq1);
     }
     Coordinate[] c1 = seq1.ToCoordinateArray();
     Coordinate[] c2 = seq2.ToCoordinateArray();
     Coordinate[] c3 = new Coordinate[c1.Length + c2.Length];
     Array.Copy(c1, 0, c3, 0, c1.Length);
     Array.Copy(c2, 0, c3, c1.Length, c2.Length);
     return(factory.CoordinateSequenceFactory.Create(c3));
 }
        /**
         * Gets the ICoordinateSequence corresponding to a compound element.
         *
         * @param idxFirst
         *            the first sub-element of the compound element
         * @param idxLast
         *            the last sub-element of the compound element
         * @param sdoGeom
         *            the SdoGeometry that holds the compound element.
         * @return
         */
        private ICoordinateSequence GetCompoundCSeq(int idxFirst, int idxLast, SdoGeometry sdoGeom)
        {
            ICoordinateSequence cs = null;

            for (int i = idxFirst; i <= idxLast; i++)
            {
                // pop off the last element as it is added with the next
                // coordinate sequence
                if (cs != null && cs.Count > 0)
                {
                    Coordinate[] coordinates    = cs.ToCoordinateArray();
                    Coordinate[] newCoordinates = new Coordinate[coordinates.Length - 1];
                    Array.Copy(coordinates, 0, newCoordinates, 0, coordinates.Length - 1);
                    cs = factory.CoordinateSequenceFactory.Create(newCoordinates);
                }
                cs = Add(cs, GetElementCSeq(i, sdoGeom, (i < idxLast)));
            }
            return(cs);
        }
Beispiel #13
0
        public static Extents3d?GetExtent(IList <Point3d> points)
        {
            var coordinates = new List <Coordinate>();

            foreach (var point in points)
            {
                var coordinate = new Coordinate()
                {
                    X = point.X,
                    Y = point.Y,
                    Z = 0
                };
                coordinates.Add(coordinate);
            }
            ICoordinateSequence coordinateSequence = CoordinateArraySequenceFactory.Instance.Create(coordinates.ToArray());
            var geometryF = new DwgWriter();
            var polygon   = geometryF.GeometryFactory.CreatePolygon(coordinateSequence.ToCoordinateArray());
            var envelop   = (Envelope)polygon.Envelope;
            var extent3D  = new Extents3d(new Point3d(envelop.MinX, envelop.MinY, 0),
                                          new Point3d(envelop.MaxX, envelop.MaxY, 0));

            return(extent3D);
        }
 protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
 {
     Coordinate[] inputPts = coords.ToCoordinateArray();
     Coordinate[] newPts;
     if (inputPts.Length == 0)
         newPts = new Coordinate[0];
     else newPts = VWLineSimplifier.Simplify(inputPts, _distanceTolerance);
     return Factory.CoordinateSequenceFactory.Create(newPts);
 }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="coords"></param>
            /// <param name="parent"></param>
            /// <returns></returns>
            protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
            {
                Coordinate[] inputPts = coords.ToCoordinateArray();
                Coordinate[] newPts = inputPts.Length == 0
                    ? new Coordinate[0]
                    : DouglasPeuckerLineSimplifier.Simplify(inputPts, _container.DistanceTolerance);

                return Factory.CoordinateSequenceFactory.Create(newPts);
            }
Beispiel #16
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="coords"></param>
 /// <param name="parent"></param>
 /// <returns></returns>
 protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
 {
     ICoordinate[] inputPts = coords.ToCoordinateArray();
     ICoordinate[] newPts   = DouglasPeuckerLineSimplifier.Simplify(inputPts, container.DistanceTolerance);
     return(factory.CoordinateSequenceFactory.Create(newPts));
 }
 /// <summary>
 /// Computes whether a ring defined by a coordinate sequence is oriented counter-clockwise.
 /// </summary>>
 /// <remarks>
 /// <list type="Bullet">
 /// <item>The list of points is assumed to have the first and last points equal.</item>
 /// <item>This will handle coordinate lists which contain repeated points.</item>
 /// </list>
 /// <para>This algorithm is only guaranteed to work with valid rings. If the ring is invalid (e.g. self-crosses or touches), the computed result may not be correct.</para>
 /// </remarks>
 /// <param name="ring">A coordinate sequence froming a ring</param>
 /// <returns>true if the ring is oriented <see cref="Orientation.CounterClockwise"/></returns>
 /// <exception cref="ArgumentException">If there are too few points to determine orientation (&lt;4)</exception>
 public static bool IsCCW(ICoordinateSequence ring)
 {
     return IsCCW(ring.ToCoordinateArray());
 }
 protected override ICoordinateSequence TransformCoordinates(
     ICoordinateSequence coords, IGeometry parent)
 {
     var inputPts = coords.ToCoordinateArray();
     var newPts = Densifier
         .DensifyPoints(inputPts, _distanceTolerance, parent.PrecisionModel);
     // prevent creation of invalid linestrings
     if (parent is ILineString && newPts.Length == 1)
     {
         newPts = new Coordinate[0];
     }
     return Factory.CoordinateSequenceFactory.Create(newPts);
 }
 private ICoordinateSequence Add(ICoordinateSequence seq1, ICoordinateSequence seq2)
 {
     if (seq1 == null)
     {
         return seq2;
     }
     if (seq2 == null)
     {
         return seq1;
     }
     Coordinate[] c1 = seq1.ToCoordinateArray();
     Coordinate[] c2 = seq2.ToCoordinateArray();
     Coordinate[] c3 = new Coordinate[c1.Length + c2.Length];
     Array.Copy(c1, 0, c3, 0, c1.Length);
     Array.Copy(c2, 0, c3, c1.Length, c2.Length);
     return factory.CoordinateSequenceFactory.Create(c3);
 }
 /// <summary>
 /// Computes whether a ring defined by a coordinate sequence is oriented counter-clockwise.
 /// </summary>>
 /// <remarks>
 /// <list type="Bullet">
 /// <item>The list of points is assumed to have the first and last points equal.</item>
 /// <item>This will handle coordinate lists which contain repeated points.</item>
 /// </list>
 /// <para>This algorithm is only guaranteed to work with valid rings. If the ring is invalid (e.g. self-crosses or touches), the computed result may not be correct.</para>
 /// </remarks>
 /// <param name="ring">A coordinate sequence froming a ring</param>
 /// <returns>true if the ring is oriented <see cref="Orientation.CounterClockwise"/></returns>
 /// <exception cref="ArgumentException">If there are too few points to determine orientation (&lt;4)</exception>
 public static bool IsCCW(ICoordinateSequence ring)
 {
     return(IsCCW(ring.ToCoordinateArray()));
 }
Beispiel #21
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="coords"></param>
 /// <param name="parent"></param>
 /// <returns></returns>
 protected override ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent)
 {
     ICoordinate[] srcPts = coords.ToCoordinateArray();
     ICoordinate[] newPts = SnapLine(srcPts, snapPts);
     return factory.CoordinateSequenceFactory.Create(newPts);
 }
    ///** Convience method for STRUCT construction. */
    //private STRUCT toSTRUCT( Datum attributes[], String dataType )
    //        throws SQLException
    //{
    //    if( dataType.startsWith("*.")){
    //        dataType = "DRA."+dataType.substring(2);//TODO here
    //    }
    //    StructDescriptor descriptor =
    //        StructDescriptor.createDescriptor( dataType, connection );
    
    //     return new STRUCT( descriptor, connection, attributes );
    //}
    
    ///** 
    // * Convience method for ARRAY construction.
    // * <p>
    // * Compare and contrast with toORDINATE - which treats <code>Double.NaN</code>
    // * as<code>NULL</code></p>
    // */
    //private ARRAY toARRAY( double doubles[], String dataType )
    //        throws SQLException
    //{
    //    ArrayDescriptor descriptor =
    //        ArrayDescriptor.createDescriptor( dataType, connection );
        
    //     return new ARRAY( descriptor, connection, doubles );
    //}
    
    ///** 
    // * Convience method for ARRAY construction.
    // */
    //private ARRAY toARRAY( int ints[], String dataType )
    //    throws SQLException
    //{
    //    ArrayDescriptor descriptor =
    //        ArrayDescriptor.createDescriptor( dataType, connection );
            
    //     return new ARRAY( descriptor, connection, ints );
    //}

    ///** 
    // * Convience method for NUMBER construction.
    // * <p>
    // * Double.NaN is represented as <code>NULL</code> to agree
    // * with JTS use.</p>
    // */
    //private NUMBER toNUMBER( double number ) throws SQLException{
    //    if( Double.isNaN( number )){
    //        return null;
    //    }
    //    return new NUMBER( number );
    //}

    /**
     * reverses the coordinate order
     *
     * @param factory
     * @param sequence
     *
     * @return CoordinateSequence reversed sequence
     */
    private ICoordinateSequence reverse(ICoordinateSequenceFactory factory, ICoordinateSequence sequence) 
    {
    	var list = new CoordinateList(sequence.ToCoordinateArray());
        list.Reverse();
        return factory.Create(list.ToCoordinateArray());
    }
 /// <summary>
 /// Returns a CoordinateSequence based on the given coordinate sequence; whether or not the
 /// array is copied is implementation-dependent.
 /// </summary>
 /// <param name="coordSeq"></param>
 /// <returns></returns>
 public ICoordinateSequence Create(ICoordinateSequence coordSeq)
 {
     if (type == PackedType.Double)
          return new PackedDoubleCoordinateSequence(coordSeq.ToCoordinateArray(), dimension);
     else return new PackedFloatCoordinateSequence(coordSeq.ToCoordinateArray(), dimension);
 }
        private static void PerformTest(ICoordinateSequence sequence)
        {
            if (sequence == null)
                throw new ArgumentNullException("sequence");

            Coordinate[] coordinates = sequence.ToCoordinateArray();
            NodedSegmentString segmentString = new NodedSegmentString(coordinates, null);
            Stopwatch watch = new Stopwatch();
            NodingValidator validator = new NodingValidator(new[] { segmentString });
            validator.CheckValid();
            watch.Start();
            validator.CheckValid();
            watch.Stop();
            Console.WriteLine("NodingValidator.CheckValid => ElapsedMilliseconds: {0}", watch.ElapsedMilliseconds);

            BasicSegmentString segmentStringBasic = new BasicSegmentString(coordinates, null);
            FastNodingValidator fastValidator = new FastNodingValidator(new[] { segmentStringBasic });
            watch.Reset(); watch.Start();
            fastValidator.CheckValid();
            watch.Stop();
            Console.WriteLine("FastNodingValidator.CheckValid => ElapsedMilliseconds: {0}", watch.ElapsedMilliseconds);
        }