判断点是否在多边形内

最新推荐文章于 2020-11-13 16:49:31 发布
最新推荐文章于 2020-11-13 16:49:31 发布
阅读量689 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TrudgeCarrot/article/details/50972034
版权 
using System.Collections;
using System;
using Utility;

public class Line
{
    public enum ExpressionType
    {
        ETYPE_NULL = 0,
        ETYPE_NORMAL = 1,   //一般式
        ETYPE_KXY = 2,      //点斜式
    }
    private ExpressionType _Type = ExpressionType.ETYPE_NULL;

    private float _Def_A = 1;
    private float _Def_B = 0;
    private float _Def_C = 0;

    private Point _Def_Pos = new Point(0,0);    //某一坐标点
    private float _Def_K = 0;                       //斜率
    private bool _isVerticalWithX = false;          //垂直与x轴斜率不存在 _Def_K 没有意义

    //一般式
    public Line(float A, float B, float C)
    {
        if (A == 0 && B == 0)
        {
            throw new Exception("can't to create a line");
        }
        _Def_A = A;
        _Def_B = B;
        _Def_C = C;
        _Type = ExpressionType.ETYPE_NORMAL;
    }
    //点斜式
    public Line(float k, Point pos, bool isVerticalWithX = false)
    {
        _Type = ExpressionType.ETYPE_KXY;
        _Def_Pos = pos.Clone();
        _Def_K = k;
        _isVerticalWithX = isVerticalWithX;
    }

    public static Line GetLine(float A, float B, float C)
    {
        Line TLine = null;
        try
        {
            TLine = new Line(A, B, C);
        }
        catch (System.Exception ex)
        {
            return null;
        }
        return TLine;
    }

    public static Line GetLine(float k, Point pos, bool isVerticalWithX = false)
    {
        return new Line(k, pos, isVerticalWithX);
    }

    //判断一个点是否在直线上
    public bool CheckPointIsInLine(Point pos)
    {
        if (_Type == ExpressionType.ETYPE_NORMAL)
        {
            if (((_Def_A * pos.x) + (_Def_B * pos.y) + _Def_C) == 0)
            {
                return true;
            }
        }
        else if (_Type == ExpressionType.ETYPE_KXY)
        {
            if ((_Def_K * (pos.x - _Def_Pos.x)) == (pos.y - _Def_Pos.y))
            {
                return true;
            }
        }

        return false;
    }
    //得到 x 确定 求y
    public Point getInLinePointByX(float x)
    {
        Point point = new Point();
        point.x = x;
        if (_Type == ExpressionType.ETYPE_NORMAL)
        {
            if (_Def_B == 0)    //无数种情况 或一种也不符合
                return null;
            point.y = (-_Def_C - _Def_A * x) / _Def_B;
        }
        else if (_Type == ExpressionType.ETYPE_KXY)
        {
            if (_isVerticalWithX)
                return null;
            point.y = _Def_K * (x - _Def_Pos.x) + _Def_Pos.y;
        }
        return point;
    }
    //得到 y 确定 求 x
    public Point getInLinePointByY(float y)
    {
        Point point = new Point();
        point.y = y;
        if (_Type == ExpressionType.ETYPE_NORMAL)
        {
            if (_Def_A == 0f)    //无数种情况 或一种也不符合
                return null;
            point.x = (-_Def_C - _Def_B * y) / _Def_A;
        }
        else if (_Type == ExpressionType.ETYPE_KXY)
        {
            if (_Def_K == 0f)
                return null;
            point.x = (y - _Def_Pos.y) / _Def_K + _Def_Pos.x;
        }
        return point;
    }

    //判断线段是否与直线相交
    //原理：线段2端(x1,y1)和(x2,y2)，直线方程f(x,y)=0，则f(x1,y1)*f(x2,y2)<=0时线段和直线相交
    public LineWithSegmentRetins CheckSegmentIsCrossLine(Segment segment)
    {
        if (segment == null)
            return LineWithSegmentRetins.LSR_Independent;
        float flag0 = 1;
        float flag1 = 1;
        if (_Type == ExpressionType.ETYPE_NORMAL)
        {
            flag0 = (_Def_A * segment._start.x) + (_Def_B * segment._start.y) + _Def_C;
            flag1 = (_Def_A * segment._end.x) + (_Def_B * segment._end.y) + _Def_C;
        }
        else if (_Type == ExpressionType.ETYPE_KXY)
        {
            flag0 = _isVerticalWithX ? segment._start.x - _Def_Pos.x : _Def_K * (segment._start.x - _Def_Pos.x) - (segment._start.y - _Def_Pos.y);
            flag1 = _isVerticalWithX ? segment._end.x - _Def_Pos.x : _Def_K * (segment._end.x - _Def_Pos.x) - (segment._end.y - _Def_Pos.y);
        }
        if(flag0 == 0 && flag1 == 0)
            return LineWithSegmentRetins.LSR_Cross_Coincide;
        else if(flag0 == 0 || flag1 == 0)
            return LineWithSegmentRetins.LSR_Cross_In;
        else if(flag0 * flag1 < 0)
            return LineWithSegmentRetins.LSR_Cross;
        return LineWithSegmentRetins.LSR_Independent;
    }


    public ExpressionType GetType()
    {
        return _Type;
    }

    public bool GetXYKLineIsVerticalWithX()
    {
        return (_Type == ExpressionType.ETYPE_KXY) && _isVerticalWithX;
    }
}

using System.Collections;
using Utility;
using System;

public class Segment {
    public Point _start;
    public Point _end;
    public Segment(Point start, Point end)
    {
        if (start == end)
        {
            throw new Exception("can't to create a segment");
        }

        _start = start.Clone();
        _end = end.Clone();
    }

    public static bool CheckSegment(Point start, Point end)
    {
        return !(start == end);
    }

    public bool CheckPointIsInSegment(Point point)
    {
        return Utility.Utility.CrossMultiply(point, _start, _end) == 0f && (point.x >= Utility.Utility.getMin(_start.x, _end.x) && point.x <= Utility.Utility.getMax(_start.x, _end.x));
    }

}
using System.Collections;
using System.Collections.Generic;
using System;
using Utility;
/// <summary>
///  多边形
/// </summary>
public class Polygon {

    public List<Point> _Pos_list = new List<Point>();
    public Polygon(List<Point> pos_list, bool checkLegal = true)
    {
        if(pos_list.Count < 3)
        {
            throw new Exception("can't to create a polygon");
        }

        if(checkLegal && !ChackIsPolygon(pos_list))
            throw new Exception("can't to create a polygon");
        else if(!checkLegal)
        {
            //三个点组成的直线
            //即使三个点在一条直线上，也认为是一个多边形
            //组成的多边形有交叉，是多个多变形的组合， 也认为是一个多边形
        }

        _Pos_list.Clear();
        for(int index = 0; index < pos_list.Count; index++)
        {
            _Pos_list.Add(pos_list[index].Clone());
        }
    }

    //组成矩形的边不能重合， 不能与第三条边相交
    public static bool ChackIsPolygon(List<Point> pos_list)
    {
        if (pos_list.Count < 3)
            return false;
        List<Segment> segment_list = new List<Segment>();
        //提取线段
        for (int index = 0; index < pos_list.Count; index++)
        {
            segment_list.Add(new Segment(pos_list[index].Clone(), pos_list[index == pos_list.Count - 1 ? 0 : index + 1].Clone()));
        }
        //判断相交
        for (int x = 0; x < segment_list.Count; x++)
        {
            for (int y = x + 1; y < segment_list.Count; y++)
            {
                SegmentsRelations flag = Utility.Utility.CheckSegmentsIntersect(segment_list[x], segment_list[y]);
                //当 当前线段与不相邻的线段相交 肯定不符合
                //当矩形的2条相邻边重合和这两条边的另外两条领边必有一条边与其重合的边中非领边的边有焦点
                if ((y - x > 1 && !(x == 0 && y == segment_list.Count - 1)) && flag > SegmentsRelations.SR_Independent)
                    return false;                
            }
        }
        return true;
    }

    public List<Segment> getSegments()
    {
        List<Segment> segment_list = new List<Segment>();
        //提取线段
        for (int index = 0; index < _Pos_list.Count; index++)
        {
            segment_list.Add(new Segment(_Pos_list[index].Clone(), _Pos_list[index == _Pos_list.Count - 1 ? 0 : index + 1].Clone()));
        }
        return segment_list;
    }
}
using System.Collections;
using System.Collections.Generic;
using System;

namespace Utility
{
    //2条线段之间的关系
    public enum SegmentsRelations
    {
        SR_Independent = -1,            //不相交
        SR_Cross = 0,                   //相交
        SR_Cross_In = 1,                //相交 一个点重合
        SR_Cross_Coincide = 3,          //相交 共线
    }

    //直线和线段之间的关系
    public enum LineWithSegmentRetins
    {
        LSR_Independent = -1,           //不相交
        LSR_Cross = 0,                  //相交
        LSR_Cross_In = 1,               //相交 线段 一个点重合 
        LSR_Cross_Coincide = 3,         //相交 重合
    }

    public class Point
    {
        public Point()
        {

        }
        public Point(float tx, float ty)
        {
            x = tx;
            y = ty;
        }
        public float x = 0;
        public float y = 0;

        public Point Clone()
        {
            return new Point(x,y);
        }

        public string ToString()
        {
            return "Point( " + x.ToString() + " , " + y.ToString() + " )"; 
        }
    }    

    public static class Utility
    {
        public static float getAbs(float src)
        {
            return src < 0 ? (-src) : src;
        }

        public static float getMax(float arg0, float arg1)
        {
            return arg0 > arg1 ? arg0 : arg1;
        }
        public static float getMin(float arg0, float arg1)
        {
            return arg0 > arg1 ? arg1 : arg0;
        }
        /*---------------------*/
        // 判断直线是否与线段相交
        /*---------------------*/
        public static LineWithSegmentRetins CheckSegmentIsCrossLine(Line line, Segment segment)
        {
            if (line == null || segment == null)
                return LineWithSegmentRetins.LSR_Independent;

            return line.CheckSegmentIsCrossLine(segment);
        }

        public static bool CheckPointIsInSegment(Segment se, Point point)
        {
            if (se == null || point == null)
                return false;
            return se.CheckPointIsInSegment(point);
        }

        /*---------------------------------------------------------------------------*/
        //  
        //                      判断两个边垂直与x轴或者y轴的矩形是否相交
        //
        //  参数为 矩形的对角线 端点
        //  原理 两个矩形的中心点在x轴，y轴上的距离 都小于等于 两个矩形的宽或者高的一半之和
        //  即使对角线垂直x轴或者y轴 不影响逻辑判断
        /*---------------------------------------------------------------------------*/
        public static bool CheckRectanglesIntersect(Point Rect0_p0, Point Rect0_p1, Point Rect1_p0, Point Rect1_p1)
        {
            /*float Halfheight = (getAbs(Rect0_p0.y - Rect0_p1.y) + getAbs(Rect1_p0.y - Rect1_p1.y)) / 2.0f;
            float Halfwide = (getAbs(Rect0_p0.x - Rect0_p1.x) + getAbs(Rect1_p0.x - Rect1_p1.x)) / 2.0f;
            float centerdistanceX = getAbs((Rect0_p0.x + Rect0_p1.x)  - (Rect1_p0.x + Rect1_p1.x))/ 2f;
            float centerdistanceY = getAbs((Rect0_p0.y + Rect0_p1.y)  - (Rect1_p0.y + Rect1_p1.y)) / 2f;
            if (centerdistanceX <= Halfwide && centerdistanceY <= Halfheight)
                return true;*/
            //简化为
            if (getAbs((Rect0_p0.x + Rect0_p1.x) - (Rect1_p0.x + Rect1_p1.x)) <= getAbs(Rect0_p0.x - Rect0_p1.x) + getAbs(Rect1_p0.x - Rect1_p1.x) && getAbs((Rect0_p0.y + Rect0_p1.y) - (Rect1_p0.y + Rect1_p1.y)) <= getAbs(Rect0_p0.y - Rect0_p1.y) + getAbs(Rect1_p0.y - Rect1_p1.y))
                return true;
            return false;
        }        

        /*********************************************************************************************
         *              
         *                                  判断 2条线段是否相交
         *              
         *  原理 1快速排除 （排除2条线段在同一直线上时 不相交）
         *       2 两条线段相交 必然相互 相交， 两条线段的两个端点各自在另一线段的两侧或有一端点在另一线段上
         *
        **********************************************************************************************/
        public static SegmentsRelations CheckSegmentsIntersect(Segment s0, Segment s1)
        {
            if (!CheckRectanglesIntersect(s0._start, s0._end, s1._start, s1._end))
                return SegmentsRelations.SR_Independent;
            //跨立原理
            /***********************************************************************************************************************************
             * 向量的叉乘 几何意义垂直与两向量的向量(实际运算得出的是伪向量，绝对值为垂直与两向量的模，也等于以两向量为2边组成的平行四边形的面积）
             * 设向量P（A1,A2) 向量Q (B1,B2)
             * P X Q = -（Q X P)
             * P X Q = A1*B2 - A2*B1   //（A1*B2 - A2*B1 的绝对值为平行四边形的面积）
             * 右手原理 右手半握，大拇指垂直向上，四指右向量P握向Q，大拇指的方向就是叉积的方向
             * 当 A1*B2 - A2*B1  大于 0 时 P 在 Q的顺时针方向 （右手原理 ）
             * 
             *   !!!!!!!!!!!!!以上大一数学有学!!!!!!!!!!!!!!
             * 
             * 当P X Q > 0   //P在Q的顺时针方向 拇指向下
             * 当P X Q < 0   //P在Q的逆时针方向 拇指向上
             * 当P X Q = 0   //p Q 共线 方向不确定是否相同 拇指范围为垂直与共线的平面的圆
             * 
             *  p 跨立 Q  (A1 - B1) X (B2 - B1)   （A2 - B1) X (B2 - B1)  得出的值正负相反时 跨立
             *  所以 (A1 - B1) X (B2 - B1) *（A2 - B1) X (B2 - B1) < 0 当 = 0 时 因为已通过快速排除 2线段必然重合
             *  简化为 (A1 - B1) X (B2 - B1) * (B2 - B1) X （A2 - B1) >= 0
             ***********************************************************************************************************************************/
            float flag0 = CrossMultiply(s0._start, s1._end, s1._start);
            float flag1 = CrossMultiply(s1._end, s0._end, s1._start);
            if (flag0 == 0f && flag1 == 0f)
                return SegmentsRelations.SR_Cross_Coincide;
            else if (flag0 == 0 || flag1 == 0)
            {
                if (s0.CheckPointIsInSegment(s1._start) || s0.CheckPointIsInSegment(s1._end) || s1.CheckPointIsInSegment(s0._start) || s1.CheckPointIsInSegment(s0._end))
                    return SegmentsRelations.SR_Cross_In;
                else
                    return SegmentsRelations.SR_Independent;
            }
            else if (flag0 * flag1 > 0)
            {
                float flag2 = CrossMultiply(s1._start, s0._end, s0._start);
                float flag3 = CrossMultiply(s0._end, s1._end, s0._start);
                if (flag2 * flag3 > 0)
                    return SegmentsRelations.SR_Cross;
                else
                    return SegmentsRelations.SR_Independent;
            }
            return SegmentsRelations.SR_Independent;
        }
        //向量 AC BC的叉乘
        public static float CrossMultiply(Point A, Point B, Point C)
        {
            return (A.x - C.x) * (B.y - C.y) - (A.y - C.y) * (B.x - C.x);
        }

        /******************************************************************
         *
         *                      判断一个点是否在多边形内  
         * 
         *    以该点做平行与x轴直线 当且仅当 直线在点两侧与矩形的交点个数为奇数时
         *                          该点在多边形内
         *                          
         *     当一侧的交点为奇数时，另一侧肯定也为奇数 所以只用证明一侧即可
         * 
        ******************************************************************/
        public static bool CheckPointInPolygon(Point point, Polygon polygon)
        {
            if (point == null || polygon == null)
                return false;
            // 排除 点在多边形边山的情况
            List<Segment> segment_list = polygon.getSegments();
            for (int index = 0; index < segment_list.Count; index++)
            {
                if (segment_list[index].CheckPointIsInSegment(point))
                    return true;
            }
            // 直线 y = point.y
            Line lineX = new Line(0f,1f,-point.y);
            //检测右边
            int crossCount = 0;
            for (int index = 0; index < segment_list.Count; index++)
            {
                LineWithSegmentRetins type = CheckSegmentIsCrossLine(lineX, segment_list[index]);
                if (type == LineWithSegmentRetins.LSR_Independent || type == LineWithSegmentRetins.LSR_Cross_Coincide)
                {
                    //不相交 和 重合的边不算在交点计数里面
                    continue;
                }
                else if (type == LineWithSegmentRetins.LSR_Cross)
                {
                    //判断交点是否在右侧 判断线段两端点与 point 的向量是否在 以线段所在的向量的 夹角

                    Point hPoint = null;
                    Point lPoint = null;
                    if (segment_list[index]._start.y > segment_list[index]._end.y)
                    {
                        hPoint = segment_list[index]._start;
                        lPoint = segment_list[index]._end;
                    }
                    else
                    {
                        hPoint = segment_list[index]._end;
                        lPoint = segment_list[index]._start;
                    }
                    if (CrossMultiply(point, lPoint, hPoint) > 0f)
                    {
                        crossCount++;
                    }
                }
                else if (type == LineWithSegmentRetins.LSR_Cross_In)
                {

                    //在 point y 轴上面的不计数  
                    if ((segment_list[index]._start.y == point.y && segment_list[index]._end.y < point.y) || (segment_list[index]._end.y == point.y && segment_list[index]._start.y < point.y))
                    {
                        //判断右侧
                        Point hPoint = null;
                        Point lPoint = null;
                        if (segment_list[index]._start.y > segment_list[index]._end.y)
                        {
                            hPoint = segment_list[index]._start;
                            lPoint = segment_list[index]._end;
                        }
                        else
                        {
                            hPoint = segment_list[index]._end;
                            lPoint = segment_list[index]._start;
                        }
                        if (CrossMultiply(point, lPoint, hPoint) > 0f)
                        {
                            crossCount++;
                        }
                    }
                }

            }
            return crossCount % 2 == 1;
        }        
    }
}
TrudgeCarrot
关注
判断点是否在多边形内(C++代码）
三维点云技术探索
03-09 1124
是一个两个数据X，Y的结构体；参数：p指目标点， ptPolygon指多边形的点集合， nCount指多边形的边数。作用：判断点是否在多边形内。
判断点在多边形内的算法
gghhb12的博客
04-01 1707
在计算几何中，判定点是否在多边形内，是个非常有趣的问题。
一种判断点与多边形关系的快速算法
09-16
高效计算点与多边形关系算法，可用于坐标点与区域的关系计算
判断点是否在多边形内部
weixin_34008933的博客
05-11 250
如何判断一个点是否在多边形内部？ （1）面积和判别法：判断目标点与多边形的每条边组成的三角形面积和是否等于该多边形，相等则在多边形内部。 （2）夹角和判别法：判断目标点与所有边的夹角和是否为360度，为360度则在多边形内部。 （3）引射线法：从目标点出发引一条射线，看这条射线和多边形所有边的交点数目。如果有奇数个交点，则说明在内部，如果有偶数个交点，则说明在外部。 具体做法：将测试点的Y...
Unity3d判断当前位置是否在不规则形状里面(PolygonCollider2D)
月夜何干
03-13 2632
using UnityEngine.UI; using UnityEngine.EventSystems; public class Test : MonoBehaviour,IPointerClickHandler { private PolygonCollider2D Collider2D; Vector2[] vector; // Use this for ini...
Unity3d判断一个点是否在多边形内
zouxin_88的专栏
11-13 2410
C#版本 public static bool ContainsPoint(Vector2[] polyPoints, Vector2 p) { var j = polyPoints.Length - 1; var inside = false; for (int i = 0; i < polyPoints.Length; j = i++) { var pi = polyPoints[i]; .
line-segments-intersect:确定两个线段是否相交
05-29
＃line-segments-intersect确定两个线段是否彼此相交。 安装 npm install line-segments-intersect 用法 var intersects = require('line-segments-intersect'); intersects(segment1,segment2 [,precision]); segment1的两点数组segment2的两点数组而点是x和y坐标的数组小数点后的精度，默认为6 例子 var intersects = require ( 'line-segments-intersect' ) ; if ( intersects ( [ [ 0 , 0 ] , [ 10 , 10 ] ] , [ [ 10 , 0 ] , [ 0 , 10 ] ] ) { console . log ( 'two segment
python3射线法判断点是否在多边形内
01-01
本文实例为大家分享了python3射线法判断点是否在多边形内的具体代码，供大家参考，具体内容如下 #!/usr/bin/python3.4 # -*- coding:utf-8 -*- def isPointinPolygon(point, rangelist): #[[0,0],[1,1],[0,1],[0,0]...
判断点是否在多边形内文档说明1
08-08
点是否在多边形内的判断算法是计算几何领域的一个核心问题。这个算法的基本思路是通过射线交叉法，即从点P出发，向左或向右画一条射线L，统计射线与多边形边的交点个数。根据奇偶性规则，交点数为奇数时，点P位于...
判断点是否在多边形内(MFC)
06-03
OnMouseMove在按下鼠标左键不放时可以持续绘制多边形，而OnRButtonDown则用于判断点是否在已绘制的多边形内。 下面是一段简单的代码示例： ```cpp void CMyView::OnLButtonDown(UINT nFlags, CPoint point) { // ...
判断一个点在多边形内
bingheliefeng的专栏
04-29 530
// // main.cpp // Test // // Created by zhouzhanglin on 16/4/29. // Copyright © 2016年 zhouzhanglin. All rights reserved. // #include #include struct Vec2{ Vec2(){} Vec2(float x,float y
2D空间求一点是否在多边形内
折戟
07-13 333
转自：https://www.cnblogs.com/hont/p/6105997.html 大致流程： 1.随便选取多边形上任意一条边，以比较点和边的中心点做一条射线(这里用的伪射线)。 2.用这条射线与其他所有边判断是否相交。 3.将所有与线段相交的数量相加，如果是奇数就在多边形内。 特殊情况： 1.刚好在点上或者在线上。实际运用时会有点误差，但不影响。 2.必须是闭合线段，且不能存在包含的情况。但如果是一个数组生成的线段，不会有这种情况 代码(Unity3D)： ...
unity 计算点是否在平面范围内
qq_40795166的博客
11-13 1557
这段是网上的传入三维坐标和三维坐标集合就可以 ///<summary> /// 计算一个点是否在一个多边形范围内 /// 如果过该点的线段与多边形的交点不为零且距该点左右方向交点数量都为奇数时 该点再多边形范围内 /// <summary> /// <param name="point">测...
Unity3D 中判断点与多边形的关系
weixin_30508241的博客
08-14 866
由点发出的射线与多边形边的交点个数，如果是偶数个说明在多边形的外面，交点个数为奇数个在多边形的内部，下面是代码: public bool IsPointInPolygon(Vector2 point, Vector2[] polygon) { int polygonLength = polygon.Length, i = 0; bool inside = false; ...
[Unity算法]点是否在多边形范围内
weixin_30485379的博客
03-31 1581
[Unity算法]点是否在多边形范围内 参考链接： https://www.zhihu.com/question/26551754 http://www.cnblogs.com/leoin2012/p/6425089.html 原理如下： 代...
如何判断一个点是否在多边形内？
热门推荐
子墨的专栏
10-14 4万+
在GIS（地理信息管理系统）中，判断一个坐标是否在多边形内部是个经常要遇到的问题。乍听起来还挺复杂。根据W. Randolph Franklin 提出的PNPoly算法，只需区区几行代码就解决了这个问题。 假设多边形的坐标存放在一个数组里，首先我们需要取得该数组在横坐标和纵坐标的最大值和最小值，根据这四个点算出一个四边型，首先判断目标坐标点是否在这个四边型之内，如果在这个四边型之外，那可以跳过
5.C-Demo-排序
最新发布
09-20
5.C-Demo-排序_快速排序
java-ssm942基于ssm的保险公司营销管理系统+jsp程序源码数据库含论文.rar
09-20
本系统基于SSM(Spring+SpringMVC+MyBatis)框架,适用于毕业设计， 基于B/S模式, mysql数据库,感兴趣的朋友们可以下载研究一下。 后端采用java语言，ssm框架，mybatis操作数据源，使用软件：idea,eclipse、MySQL。完成了用户登录管理等模块的设计与实现。完成了系统数据库的设计，并基于MySQL数据库管理系统 jdk版本:jdk1.8+ 前端：jsp 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架支持：ssm 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以 详细技术：java+ssm+jsp+MYSQL+MAVEN
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值